https://www.rabbitmq.com/getstarted.html
1、Hello World!
1.1、导入依赖
<!--指定 jdk 编译版本-->
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>8</source>
<target>8</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<!--rabbitmq 依赖客户端-->
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.8.0</version>
</dependency>
</dependencies>
1.2、java代码实现
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
//rabbitmq连接工具类
public class ChannelUnit {
public static Channel getChannel() throws Exception{
//创建一个连接工厂
ConnectionFactory connectionFactory=new ConnectionFactory();
connectionFactory.setHost("127.0.0.1");
connectionFactory.setPort(5672);
connectionFactory.setUsername("guest");
connectionFactory.setPassword("guest");
//获取一个连接
Connection connection = connectionFactory.newConnection();
//创建一个信道
Channel channel=connection.createChannel();
return channel;
}
}
import com.example.wwy.rabbit.units.ChannelUnit;
import com.rabbitmq.client.Channel;
import java.util.Scanner;
//生产者
public class Producer {
//队列名称
private final static String QUEUE_NAME="Hello World";
public static void main(String[] args) throws Exception {
//获取队列
Channel channel = ChannelUnit.getChannel();
/**
*
生成一个队列
* 1.队列名称
* 2.队列里面的消息是否持久化 默认消息存储在内存中
* 3.该队列是否只供一个消费者进行消费 是否进行共享 true 可以多个消费者消费
* 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true 自动删除
* 5.其他参数
*/
channel.queueDeclare(QUEUE_NAME,false,false,false,null);
//要发送的消息体
String message="hello msg";
/**
*
发送一个消息
* 1.发送到那个交换机
* 2.路由的 key 是哪个
* 3.其他的参数信息
* 4.发送消息的消息体
*/
channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
System.out.println("消息发送完毕！");
}
}
import com.example.wwy.rabbit.units.ChannelUnit;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
//消费者
public class Consumer {
//队列名称
private final static String QUEUE_NAME="Hello World";
public static void main(String[] args) throws Exception {
//获取队列
Channel channel = ChannelUnit.getChannel();
System.out.println("等待接受消息！");
//推送的消息进行消费的借口的回调
DeliverCallback deliverCallback=(consumerTag,delivery)->{
String message=new String(delivery.getBody());
System.out.println(message);
};
//消费消息中断后执行的方法
CancelCallback cancelCallback=(var1)->{
System.out.println("消费消息被中断！");
};
/**
*
消费者消费消息
* 1.消费哪个队列
* 2.消费成功之后是否要自动应答 true 代表自动应答 false 手动应答
* 3.消费者未成功消费的回调
*/
channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
}
}
2、Work Queues在消费者之间自动分配任务（竞争消费者模式）
2.1、轮训分发消息实现
消费者新建俩个，就按上面的写；
import com.example.wwy.rabbit.units.ChannelUnit;
import com.rabbitmq.client.Channel;
import java.util.Scanner;
//生产者
public class Producer {
//队列名称
private final static String QUEUE_NAME="test2";
public static void main(String[] args) throws Exception {
//获取队列
Channel channel = ChannelUnit.getChannel();
/**
*
生成一个队列
* 1.队列名称
* 2.队列里面的消息是否持久化 默认消息存储在内存中
* 3.该队列是否只供一个消费者进行消费 是否进行共享 true 可以多个消费者消费
* 4.是否自动删除 最后一个消费者端开连接以后 该队列是否自动删除 true 自动删除
* 5.其他参数
*/
channel.queueDeclare(QUEUE_NAME,false,false,false,null);
Scanner scanner=new Scanner(System.in);
while(scanner.hasNext()){
String message= scanner.next();
/**
*
发送一个消息
* 1.发送到那个交换机
* 2.路由的 key 是哪个
* 3.其他的参数信息
* 4.发送消息的消息体
*/
channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
System.out.println("发送消息完毕");
}
}
结果： 生产者总共发送 4 个消息，消费者 1 和消费者 2 分别分得两个消息，并且
是按照有序的一个接收一次消息。
2.2、消息应答机制
RabbitMQ 一旦向消费者传递了一条消息，便立即将该消息标记为删除；
假如其中某一个消费者要执行某一个任务，需要很长时间，而且只完成了部分就挂掉了，
那么这条消息就丢失了，以及后续发送给该消费者的消息都会丢失。
这个时间就引入了消息应答模式：:消费者在接收
到消息并且处理该消息之后，告诉 rabbitmq 它已经处理了，rabbitmq 可以把该消息删除了。
2.2.1、自动应答机制
消息发送之后就会立刻被认为发送成功，这样保证了高吞吐量，但是无法保证传输安全;
消息在消费者接受到之前，出现链接或者channel关闭，那么消息就会丢失了;
消费者没有对消息数量进行限制，就可能导致接受到很多还未处理的消息，导致消息的积压，最终内存耗尽，最终被操作系统杀死。
2.2.2、消息应答的方法
1.Channel.basicAck(用于肯定确认)
RabbitMQ 已知道该消息并且成功的处理消息，可以将其丢弃了
2.Channel.basicNack(用于否定确认)
3.Channel.basicReject(用于否定确认)
与 Channel.basicNack 相比少一个参数不处理该消息了直接拒绝，可以将其丢弃了
basicAsk参数：
true代表批量应答；
比如说 channel 上有传送 tag 的消息 5,6,7,8 当前 tag 是8 那么此时
5-8 的这些还未应答的消息都会被确认收到消息应答
false与之相反：只应答消息8
2.2.3、消息自动重新入队
如果消费者由于某些原因失去连接(其通道已关闭，连接已关闭或 TCP 连接丢失)，导致消息
未发送 ACK 确认，RabbitMQ 将了解到消息未完全处理，并将对其重新排队。如果此时其他消费者
可以处理，它将很快将其重新分发给另一个消费者。这样，即使某个消费者偶尔死亡，也可以确
保不会丢失任何消息。
2.2.4、测试代码
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
//生产者线程
public class Task1 {
private static final String TASK_QUEUES_NAME="task01";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtil.getChannel();
/**
* 1.队列名称
* 2.队列里面的消息是否持久化，默认消息存储在内存中
* 3.该队列是否只向一个消费者提供消费，true可以多个消费者消费
* 4.是否自动删除，当最后一个消费者断开后，是否自动删除true为自动删除
* 5.其它参数
*/
channel.queueDeclare(TASK_QUEUES_NAME,false,false,false,null);
Scanner scanner=new Scanner(System.in);
System.out.println("请输入消息");
while(scanner.hasNext()){
String message=scanner.next();
/**
* 1.发送到那个交换机
* 2.路由的key
* 3.其他参数信息
* 4.发送的消息体
*/
channel.basicPublish("",TASK_QUEUES_NAME,null,
message.getBytes(StandardCharsets.UTF_8));
System.out.println("发送消息完毕："+message);
}
}
}
//消费者线程1
public class Work1 {
private static final String TASK_QUEUES_NAME="task01";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtil.getChannel();
System.out.println("W1处理时间很快！");
//处理接受到的消息
DeliverCallback deliverCallback=( var1, var2)->{
SleepUtils.sleep(1);
String message=new String(var2.getBody());
System.out.println(message);
//设置手动应答，接受消息，tag消息的Id,true批量应答，false单条应答
channel.basicAck(var2.getEnvelope().getDeliveryTag(), false);
};
CancelCallback cancelCallback=(consumerTag)->{
System.out.println("消费消息被中断！");
};
/**
* 1.队列名称
* 2.是否自动应答
* 3.处理消息的回调方法
* 4.消息接收失败时处理方法。
*/
channel.basicConsume(TASK_QUEUES_NAME,false,deliverCallback,cancelCallback);
}
}
//消费者线程2
public class Work2 {
private static final String TASK_QUEUES_NAME="task01";
public static void main(String[] args) throws Exception {
Channel channel = RabbitMqUtil.getChannel();
System.out.println("W2处理时间比较慢！");
//处理接受到的消息
DeliverCallback deliverCallback=(var1, var2)->{
SleepUtils.sleep(30);
String message=new String(var2.getBody());
System.out.println(message);
//设置手动应答，接受消息，tag消息的Id,true批量应答，false单条应答
channel.basicAck(var2.getEnvelope().getDeliveryTag(), false);
};
CancelCallback cancelCallback=(consumerTag)->{
System.out.println("消费消息被中断！");
};
/**
* 1.队列名称
* 2.是否自动应答
* 3.处理消息的回调方法
* 4.消息接收失败时处理方法。
*/
channel.basicConsume(TASK_QUEUES_NAME,false,deliverCallback,cancelCallback);
}
}
当消费者线程2在处理消息的时候，如果断开了链接，会由消费1去处理，防止了消息的丢失
944
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
