引言
本篇内容讲从零开始集成RabbitMQ,也就是从安装RabbitMQ的环境到消费。
正文
第一步:安装Erlang
这里只需要一直下一步就可以了,最后需要配置环境变量,如图所示:
(这里我的系统是WIN7的)
安装完成后,在cmd命令行打:erl,如果如下图所示则安装成功
第二步:安装RabbitMQ
这里只需要一直下一步就可以了,打开命令行,进入RabbitMq的sbin文件,我的安装默认是(C:\Program Files\RabbitMQ Server\rabbitmq_server-3.7.17\sbin),输入命令:rabbitmq-plugins enable rabbitmq_management ,如图则启动成功:
浏览器输入:http://localhost:15672/#/
(默认的账号和密码都是:guest),
第三步:写代码。。。。。
以上两步都能正常完成的话,代码这里就很简单了。
项目结构图
代码,从上往下复制粘贴
ExchangeConfig:
package com.hjh.rabbitmq.config;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author HJH
* @Description: 消息交换机配置
* @date 2019/7/30 15:08
*/
@Configuration
public class ExchangeConfig {
/**
* 1.定义direct exchange,绑定queueTest
* 2.durable="true" rabbitmq重启的时候不需要创建新的交换机
* 3.direct交换器相对来说比较简单,匹配规则为:如果路由键匹配,消息就被投送到相关的队列
* fanout交换器中没有路由键的概念,他会把消息发送到所有绑定在此交换器上面的队列中。
* topic交换器你采用模糊匹配路由键的原则进行转发消息到队列中
* key: queue在该direct-exchange中的key值,当消息发送给direct-exchange中指定key为设置值时,
* 消息将会转发给queue参数指定的消息队列
*/
@Bean
public DirectExchange directExchange() {
DirectExchange directExchange = new DirectExchange(RabbitMqConfig.EXCHANGE, true, false);
return directExchange;
}
}
QueueConfig:
package com.hjh.rabbitmq.config;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author HJH
* @Description: 队列配置
* @date 2019/7/30 15:09
*/
@Configuration
public class QueueConfig {
@Bean
public Queue firstQueue() {
/**
durable="true" 持久化 rabbitmq重启的时候不需要创建新的队列
auto-delete 表示消息队列没有在使用时将被自动删除 默认是false
exclusive 表示该消息队列是否只在当前connection生效,默认是false
*/
return new Queue("first-queue", true, false, false);
}
@Bean
public Queue secondQueue() {
return new Queue("second-queue", true, false, false);
}
}
RabbitMqConfig:
package com.hjh.rabbitmq.config;
/**
* @author HJH
* @Description: RabbitMq配置
* @date 2019/7/30 15:10
*/
import com.hjh.rabbitmq.mqcallback.MsgSendConfirmCallBack;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitMqConfig {
/**
* 消息交换机的名字
*/
public static final String EXCHANGE = "exchangeTest";
/**
* 队列key1
*/
public static final String ROUTINGKEY1 = "queue_one_key1";
/**
* 队列key2
*/
public static final String ROUTINGKEY2 = "queue_one_key2";
@Autowired
private QueueConfig queueConfig;
@Autowired
private ExchangeConfig exchangeConfig;
/**
* 连接工厂
*/
@Autowired
private ConnectionFactory connectionFactory;
/**
* 将消息队列1和交换机进行绑定,并指定key
*/
@Bean
public Binding binding_one() {
return BindingBuilder.bind(queueConfig.firstQueue()).to(exchangeConfig.directExchange()).with(RabbitMqConfig.ROUTINGKEY1);
}
/**
* 将消息队列2和交换机进行绑定,并指定key
*/
@Bean
public Binding binding_two() {
return BindingBuilder.bind(queueConfig.secondQueue()).to(exchangeConfig.directExchange()).with(RabbitMqConfig.ROUTINGKEY2);
}
/**
* queue listener 观察 监听模式
* 当有消息到达时会通知监听在对应的队列上的监听对象
*
* @return
*/
@Bean
public SimpleMessageListenerContainer simpleMessageListenerContainer_one() {
SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer(connectionFactory);
simpleMessageListenerContainer.addQueues(queueConfig.firstQueue());
simpleMessageListenerContainer.setExposeListenerChannel(true);
simpleMessageListenerContainer.setMaxConcurrentConsumers(5);
simpleMessageListenerContainer.setConcurrentConsumers(1);
simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认
return simpleMessageListenerContainer;
}
/**
* 定义rabbit template用于数据的接收和发送
*
* @return
*/
@Bean
public RabbitTemplate rabbitTemplate() {
RabbitTemplate template = new RabbitTemplate(connectionFactory);
/**若使用confirm-callback或return-callback,
* 必须要配置publisherConfirms或publisherReturns为true
* 每个rabbitTemplate只能有一个confirm-callback和return-callback
*/
template.setConfirmCallback(msgSendConfirmCallBack());
//template.setReturnCallback(msgSendReturnCallback());
/**
* 使用return-callback时必须设置mandatory为true,或者在配置中设置mandatory-expression的值为true,
* 可针对每次请求的消息去确定’mandatory’的boolean值,
* 只能在提供’return -callback’时使用,与mandatory互斥
*/
// template.setMandatory(true);
return template;
}
/**
* 消息确认机制
* Confirms给客户端一种轻量级的方式,能够跟踪哪些消息被broker处理,
* 哪些可能因为broker宕掉或者网络失败的情况而重新发布。
* 确认并且保证消息被送达,提供了两种方式:发布确认和事务。(两者不可同时使用)
* 在channel为事务时,不可引入确认模式;同样channel为确认模式下,不可使用事务。
*
* @return
*/
@Bean
public MsgSendConfirmCallBack msgSendConfirmCallBack() {
return new MsgSendConfirmCallBack();
}
}
SendController:
package com.hjh.rabbitmq.controller;
import com.hjh.rabbitmq.sender.FirstSender;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.UUID;
/**
* @author HJH
* @Description: 测试控制器
* @date 2019/7/30 15:13
*/
@RestController
public class SendController {
@Autowired
private FirstSender firstSender;
@GetMapping("/send")
public String send(String message) {
String uuid = UUID.randomUUID().toString();
firstSender.send(uuid, message);
return uuid;
}
}
MsgSendConfirmCallBack:
package com.hjh.rabbitmq.mqcallback;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
/**
* @author HJH
* @Description: 消息发送到交换机确认机制
* @date 2019/7/30 15:10
*/
public class MsgSendConfirmCallBack implements RabbitTemplate.ConfirmCallback {
@Override
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
System.out.println("MsgSendConfirmCallBack , 回调id:" + correlationData);
if (ack) {
System.out.println("消息消费成功");
} else {
System.out.println("消息消费失败:" + cause + "\n重新发送");
}
}
}
FirstConsumer:
package com.hjh.rabbitmq.receiver;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
/**
* @author HJH
* @Description: 消息消费者1号
* @date 2019/7/30 15:12
*/
@Component
public class FirstConsumer {
/**
* 这里监听了两个queues,只要其中一个有消息就会消费
*/
@RabbitListener(queues = {"first-queue", "second-queue"}, containerFactory = "rabbitListenerContainerFactory")
public void handleMessage(String message) throws Exception {
// 处理消息
System.out.println("FirstConsumer {} handleMessage :" + message);
}
}
SecondConsumer:
package com.hjh.rabbitmq.receiver;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
/**
* @author HJH
* @Description: 消息消费者2号
* @date 2019/7/30 15:12
*/
@Component
public class SecondConsumer {
/**
* 这里监听了两个queues,只要其中一个有消息就会消费
*/
@RabbitListener(queues = {"first-queue", "second-queue"}, containerFactory = "rabbitListenerContainerFactory")
public void handleMessage(String message) throws Exception {
// 处理消息
System.out.println("FirstConsumer {} handleMessage :" + message);
}
}
FirstSender:
package com.hjh.rabbitmq.sender;
import com.hjh.rabbitmq.config.RabbitMqConfig;
import lombok.extern.slf4j.Slf4j;
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.Component;
/**
* @author HJH
* @Description: 消息发送 生产者1
* @date 2019/7/30 15:11
*/
@Slf4j
@Component
public class FirstSender {
@Autowired
private RabbitTemplate rabbitTemplate;
/**
* 发送消息
*
* @param uuid
* @param message 消息
*/
public void send(String uuid, Object message) {
CorrelationData correlationId = new CorrelationData(uuid);
//配置交换机,队列key2,消息
rabbitTemplate.convertAndSend(RabbitMqConfig.EXCHANGE, RabbitMqConfig.ROUTINGKEY2,
message, correlationId);
}
}
application.properties:
#对于rabbitMQ的支持
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
# 消息发送到交换机确认机制,是否确认回调
spring.rabbitmq.publisher-confirms: true
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>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.hjh</groupId>
<artifactId>rabbitmq</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>rabbitmq</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<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>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>0.10.1</version>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>1.6.1.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>2.1.7.RELEASE</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
程序运行步骤与效果
1,运行RabbitmqApplication的main方法
2,访问,http://localhost:8080/send?message=6666
3,控制台打印,这里我访问了五次
可以看出,一条信息只能被消费一次,并且默认的配有负载均衡(轮询);
结语
源码可去我的git下载