RabbitMQ提供了6种工作模式:简单模式、work queues、Publish/Subscribe 发布与订阅模式、Routing路由模式、Topics 主题模式、RPC 远程调用模式
RabbitMQ安装
1.安装依赖环境
yum install build-essential openssl openssl-devel unixODBC unixODBC-devel make gcc gcc-c++ kernel-devel m4 ncurses-devel tk tc xz
2.安装Erlang
rpm -ivh erlang-18.3-1.el7.centos.x86_64.rpm
3.安装RabbitMQ
# 安装
rpm -ivh socat-1.7.3.2-5.el7.lux.x86_64.rpm
# 安装
rpm -ivh rabbitmq-server-3.6.5-1.noarch.rpm
4.启动
service rabbitmq-server start # 启动服务
service rabbitmq-server stop # 停止服务
service rabbitmq-server restart # 重启服务
5.可能出现的问题
5.1 依赖检测失败
解决：使用命令 安装tcp_wrappers 即可
6.注意的问题
使用linux 需要开启管理界面及配置问题
第一，需要先启动rabbitMQ的服务
service rabbitmq-server start # 启动服务
没有先启动可能会遇到rabbit插件配置加载失败的问题
第二，修改默认配置（不必要）
vim /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.5/ebin/rabbit.app
第三，开启管理界面
rabbitmq-plugins enable rabbitmq_management
6种工作模式
链接: https://www.rabbitmq.com/getstarted.html
1.简单模式
代码展示：
//生产者P
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2. 设置参数
factory.setHost("172.16.98.133");//ip 默认值 localhost
factory.setPort(5672); //端口 默认值 5672
factory.setVirtualHost("/test");//虚拟机 默认值/
factory.setUsername("ceshi");//用户名 默认 guest
factory.setPassword("ceshi");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
//5. 创建队列Queue
/*
queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
参数：
1. queue：队列名称
2. durable:是否持久化，当mq重启之后，还在
3. exclusive：
* 是否独占。只能有一个消费者监听这队列
* 当Connection关闭时，是否删除队列
*
4. autoDelete:是否自动删除。当没有Consumer时，自动删除掉
5. arguments：参数。
*/
//如果没有一个名字叫hello_world的队列，则会创建该队列，如果有则不会创建
channel.queueDeclare("hello_world",true,false,false,null);
/*
basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
参数：
1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
2. routingKey：路由名称
3. props：配置信息
4. body：发送消息数据
*/
String body = "hello rabbitmq~~~";
//6. 发送消息
channel.basicPublish("","hello_world",null,body.getBytes());
//7.释放资源
channel.close();
connection.close();
//消费者
//1.创建连接工厂
ConnectionFactory factory = new ConnectionFactory();
//2. 设置参数
factory.setHost("172.16.98.133");//ip 默认值 localhost
factory.setPort(5672); //端口 默认值 5672
factory.setVirtualHost("/test");//虚拟机 默认值/
factory.setUsername("ceshi");//用户名 默认 guest
factory.setPassword("ceshi");//密码 默认值 guest
//3. 创建连接 Connection
Connection connection = factory.newConnection();
//4. 创建Channel
Channel channel = connection.createChannel();
//5. 创建队列Queue
/*
queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
参数：
1. queue：队列名称
2. durable:是否持久化，当mq重启之后，还在
3. exclusive：
* 是否独占。只能有一个消费者监听这队列
* 当Connection关闭时，是否删除队列
*
4. autoDelete:是否自动删除。当没有Consumer时，自动删除掉
5. arguments：参数。
*/
//如果没有一个名字叫hello_world的队列，则会创建该队列，如果有则不会创建
channel.queueDeclare("hello_world",true,false,false,null);
/*
basicConsume(String queue, boolean autoAck, Consumer callback)
参数：
1. queue：队列名称
2. autoAck：是否自动确认
3. callback：回调对象
*/
// 接收消息
Consumer consumer = new DefaultConsumer(channel){
/*
回调方法，当收到消息后，会自动执行该方法
1. consumerTag：标识
2. envelope：获取一些信息，交换机，路由key...
3. properties:配置信息
4. body：数据
*/
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
System.out.println("consumerTag："+consumerTag);
System.out.println("Exchange："+envelope.getExchange());
System.out.println("RoutingKey："+envelope.getRoutingKey());
System.out.println("properties："+properties);
System.out.println("body："+new String(body));
}
};
channel.basicConsume("hello_world",true,consumer);
//关闭资源？不要
2.work queues
在基于简单模型的代码下 添加多个消费者队列
//生产者
for (int i = 1; i <= 10; i++) {
String body = i+"hello rabbitmq~~~";
//6. 发送消息
channel.basicPublish("","work_queues",null,body.getBytes());
}
//同时用两个消费者消费生产者生产出来的消息
//消费者1
channel.basicConsume("work_queues",true,consumer);
//消费者2
channel.basicConsume("work_queues",true,consumer);
1.在一个队列中如果有多个消费者,那么消费者之间对于同一个消息的关系是竞争的关系。
2. Work Queues对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如:短信服务部署多个，只需要有一个节点成功发送即可。
3.Publish/Subscribe 发布与订阅模式
在订阅模型中，多了一个Exchange角色，而且过程略有变化:
●P:生产者,也就是要发送消息的程序，但是不再发送到队列中，而是发给X (交换机)
●C:消费者,消息的接收者,会一直等待消息到来
●Queue:消恳队列，接收消息、缓存消息
●Exchange: 交换机(X)。- -方面，接收生产者发送的消息。另- -方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列，或是将消息丢弃。到底如何操作，取决于Exchange的类型。
Exchange有 常见以下3种类型:
Fanout:广播，将消息交给所有绑定到交换机的队列
Direct: 定向，把消息交给符合指定routing key的队列
Topic:通配符，把消息交给符合routing pattern (路由模式)的队列
Exchange (交换机)只负贵转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失!
//生产者
exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
/*
参数：
1. exchange:交换机名称
2. type:交换机类型
DIRECT("direct"),：定向
FANOUT("fanout"),：扇形（广播），发送消息到每一个与之绑定队列。
TOPIC("topic"),通配符的方式
HEADERS("headers");参数匹配
3. durable:是否持久化
4. autoDelete:自动删除
5. internal：内部使用。 一般false
6. arguments：参数
*/
String exchangeName = "test_fanout";
//5. 创建交换机
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
//6. 创建队列
String queue1Name = "test_fanout_queue1";
String queue2Name = "test_fanout_queue2";
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
//7. 绑定队列和交换机
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1. queue：队列名称
2. exchange：交换机名称
3. routingKey：路由键，绑定规则
如果交换机的类型为fanout ，routingKey设置为""
*/
channel.queueBind(queue1Name,exchangeName,"");
channel.queueBind(queue2Name,exchangeName,"");
String body = "日志信息：张三调用了findAll方法...日志级别：info...";
//8. 发送消息
channel.basicPublish(exchangeName,"",null,body.getBytes());
//9. 释放资源
channel.close();
connection.close();
//消费者1
channel.basicConsume(queue1Name,true,consumer);
//消费者2
channel.basicConsume(queue2Name,true,consumer);
4.Routing路由模式
队列与交换机的绑定，不能是任意绑定了，而是要指定-个RoutingKey (路由key)消息的发送方在向Exchange发送消息时，也必须指定消息的RoutingKey
Exchange不再把消息交给每一一个绑定的队列，而是根据消息的RoutingKey进行判断，只有队列的Routingkey与消息的Routing key完全一致， 才会接收到消息
//生产者
/*
exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
参数：
1. exchange:交换机名称
2. type:交换机类型
DIRECT("direct"),：定向
FANOUT("fanout"),：扇形（广播），发送消息到每一个与之绑定队列。
TOPIC("topic"),通配符的方式
HEADERS("headers");参数匹配
3. durable:是否持久化
4. autoDelete:自动删除
5. internal：内部使用。 一般false
6. arguments：参数
*/
String exchangeName = "test_direct";
//5. 创建交换机
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT,true,false,false,null);
//6. 创建队列
String queue1Name = "test_direct_queue1";
String queue2Name = "test_direct_queue2";
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
//7. 绑定队列和交换机
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1. queue：队列名称
2. exchange：交换机名称
3. routingKey：路由键，绑定规则
如果交换机的类型为fanout ，routingKey设置为""
*/
//队列1绑定 error
channel.queueBind(queue1Name,exchangeName,"error");
//队列2绑定 info error warning
channel.queueBind(queue2Name,exchangeName,"info");
channel.queueBind(queue2Name,exchangeName,"error");
channel.queueBind(queue2Name,exchangeName,"warning");
String body = "日志信息：张三调用了delete方法...出错误了。。。日志级别：error...";
//8. 发送消息
channel.basicPublish(exchangeName,"warning",null,body.getBytes());
//消费者1
channel.basicConsume(queue1Name,true,consumer);
//消费者2
channel.basicConsume(queue2Name,true,consumer);
5.Topics 主题模式
//String exchangeName = "test_topic";
//5. 创建交换机
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);
//6. 创建队列
String queue1Name = "test_topic_queue1";
String queue2Name = "test_topic_queue2";
channel.queueDeclare(queue1Name,true,false,false,null);
channel.queueDeclare(queue2Name,true,false,false,null);
//7. 绑定队列和交换机
/*
queueBind(String queue, String exchange, String routingKey)
参数：
1. queue：队列名称
2. exchange：交换机名称
3. routingKey：路由键，绑定规则
如果交换机的类型为fanout ，routingKey设置为""
*/
// routing key 系统的名称.日志的级别。
//=需求： 所有error级别的日志存入数据库，所有order系统的日志存入数据库
channel.queueBind(queue1Name,exchangeName,"#.error");
channel.queueBind(queue1Name,exchangeName,"order.*");
channel.queueBind(queue2Name,exchangeName,"*.*");
String body = "日志信息：张三调用了findAll方法...日志级别：info...";
//8. 发送消息
channel.basicPublish(exchangeName,"goods.error",null,body.getBytes());
6.RPC 远程调用模式
前面的几种模式都是生产者发布了消息到达队列之后，这些消息如何被处理就不管了，现在RPC模式就是客户端发送RPC请求并进入阻塞状态，直到收到服务端处理这些消息之后并返回答案为止，在远程计算机上运行功能并等待结果这种模式通常称为“ 远程过程调用”或“ RPC”。
整合
Spirng整合
1.生产者
//spring xml配置文件
<!--加载配置文件-->
<context:property-placeholder location="classpath:rabbitmq.properties"/>
<!-- 定义rabbitmq connectionFactory -->
<rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
port="${rabbitmq.port}"
username="${rabbitmq.username}"
password="${rabbitmq.password}"
virtual-host="${rabbitmq.virtual-host}"/>
<bean id="springQueueListener" class="com.itheima.rabbitmq.listener.SpringQueueListener"/>
<bean id="fanoutListener1" class="com.itheima.rabbitmq.listener.FanoutListener1"/>
<bean id="fanoutListener2" class="com.itheima.rabbitmq.listener.FanoutListener2"/>
<bean id="topicListenerStar" class="com.itheima.rabbitmq.listener.TopicListenerStar"/>
<bean id="topicListenerWell" class="com.itheima.rabbitmq.listener.TopicListenerWell"/>
<bean id="topicListenerWell2" class="com.itheima.rabbitmq.listener.TopicListenerWell2"/>
<rabbit:listener-container connection-factory="connectionFactory" auto-declare="true">
<rabbit:listener ref="springQueueListener" queue-names="spring_queue"/>
<rabbit:listener ref="fanoutListener1" queue-names="spring_fanout_queue_1"/>
<rabbit:listener ref="fanoutListener2" queue-names="spring_fanout_queue_2"/>
<rabbit:listener ref="topicListenerStar" queue-names="spring_topic_queue_star"/>
<rabbit:listener ref="topicListenerWell" queue-names="spring_topic_queue_well"/>
<rabbit:listener ref="topicListenerWell2" queue-names="spring_topic_queue_well2"/>
</rabbit:listener-container>
//发送消息
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
public class producerTest {
//1.注入RabbitTemplate
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void test(){
//2.发送消息
rabbitTemplate.convertAndSend("spring_queue","hello World spring...");
}
}
2.消费者
//接收消息
//1.继承消息监听类 重写onMessage方法获取消息体
public class SpringQueueListener implements MessageListener {
@Override
public void onMessage(Message message) {
System.out.println(new String(message.getBody()));
}
}
SpringBoot整合
RabbitMQ特性
1.消息的可靠投递
在使用RabbitMQ的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。（confirm确认模式、return 退回模式）
rabbitmq整个消息投递的路径为:
producer—> rabbitmq broker—> exchange—> queue—> consumer
●消息从producer到exchange则会返回一个confirmCallback .
●消息从exchange–> queue投递失败则会返回一个returnCallback。
publisher- confirms=”true
publisher- returns= "true
2.Consumer ack
//1.设置手动签收 acknowledge= "manual"
<rabbit:listener-container connection-factory="connectionFactory" auto-declare="true" acknowledge="manual">
<rabbit:listener ref="springQueueListener" queue-names="spring_queue"/>
</rabbit:listener-container>
/*
* Consumer ACK机制:
*
1.设置手动签收。acknowledge= "manual"
* 2.让监听器类实现ChanneLAwareMessageL istener接口
*
3.如果消息成功处理，则调用channel的basicAck()签收
*
4.如果消息处理失败，则调用channeL的basicNack( )拒绝签收，broker重新发送给consumer
中
*/
@Component
public Class AckListener implements ChannelAwareMessagelistener {
@override
public void onMessage(Message message, Channel channel) throws Exception {
try {
//1.接收转换消息
System. out . println( new String(message . getBody())); .
//2.处理业务逻辑
System. out. println( "处理业务逻辑...");
//int i = 3/0;//出现错误
//3.手动签收
channel . basicAck(deliveryTag, multiple: true);
} catch (Exception e) {
//e. printStackTrace();|
//4.拒绝签收
I
/*
第三个参数: requeue: 重回队列。如果设置为true,则消息重新回到queue, broker会 重新发送该消息给消费端
channel . basicNack(deliveryTag, multiple: true, requeue: true);
}
}
3.消费端限流
在 rabbit:listener-container中配置prefetch属性设置消费端一次拉去多少消息
消费端的确认模式-定为手动确认。acknowledge= “manual”
705
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
