Work轮询模式讲解
- 1、轮询模式的分发:—个消费者条，按均分配;
- 2、公平分发︰根据消费者的消费的力进行公平分发，处理快的处理的多，处理慢的处理的少;按劳分配;
producer
package com.tian.rabbitmq.work.lunxun;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class Producer {
public static void main(String[] args) {
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.1.150");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
connection = connectionFactory.newConnection("生产者");
channel = connection.createChannel();
for (int i = 0; i <=20; i++) {
String msg="学相伴："+i;
channel.basicPublish("","queue1",null,msg.getBytes());
}
System.out.println("消息发送成功");
} catch (Exception ex) {
ex.printStackTrace();
}finally {
if(channel!=null&&channel.isOpen()){
try {
channel.close();
}catch (Exception ex){
ex.printStackTrace();
}
}
if(connection!=null&&connection.isOpen()){
try {
connection.close();
}catch (Exception ex){
ex.printStackTrace();
}
}
}
}
}
work
package com.tian.rabbitmq.work.lunxun;
import com.rabbitmq.client.*;
import java.io.IOException;
public class Worker {
public static void main(String[] args) {
//1:创建连接工程
ConnectionFactory connectionFactory = new ConnectionFactory();
connectionFactory.setHost("192.168.1.150");
connectionFactory.setPort(5672);
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
connectionFactory.setVirtualHost("/");
Connection connection = null;
Channel channel = null;
try {
//2:创建连接connection
connection = connectionFactory.newConnection("生产者");
//3:通过连接获取通道Channel
channel = connection.createChannel();
channel=connection.createChannel();
Channel finalChanel=channel;
// finalChanel.basicQos(1);
finalChanel.basicConsume("queue1", true, new DeliverCallback() {
public void handle(String s, Delivery delivery) throws IOException {
try {
System.out.println("work1收到消息是" + new String(delivery.getBody(), "UTF-8" ));
} catch (Exception ex) {
ex.printStackTrace();
}
}
}, new CancelCallback() {
public void handle(String s) throws IOException {
}
});
System.out.println("work1开始接收消息");
System.in.read();
} catch (Exception ex) {
ex.printStackTrace();
}finally {
//7:关闭连接
if(channel!=null&&channel.isOpen()){
try {
channel.close();
}catch (Exception ex){
ex.printStackTrace();
}
}
//8:关闭通道
if(connection!=null&&connection.isOpen()){
try {
connection.close();
}catch (Exception ex){
ex.printStackTrace();
}
}
}
}
}
work2 同 work1
现象 10个work消费 10个work2消费10个
Work公平分发讲解
producer
package com.tian.rabbitmq.work.fair;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
/**
* @author: 学相伴-飞哥
* @description: Producer 简单队列生产者
* @Date : 2021/3/2
*/
public class Producer {
public static void main(String[] args) {
// 1: 创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
// 2: 设置连接属性
connectionFactory.setHost("192.168.1.150");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
Connection connection = null;
Channel channel = null;
try {
// 3: 从连接工厂中获取连接
connection = connectionFactory.newConnection("生产者");
// 4: 从连接中获取通道channel
channel = connection.createChannel();
// 6： 准备发送消息的内容
//===============================end topic模式==================================
for (int i = 1; i <= 20; i++) {
//消息的内容
String msg = "学相伴:" + i;
// 7: 发送消息给中间件rabbitmq-server
// @params1: 交换机exchange
// @params2: 队列名称/routingkey
// @params3: 属性配置
// @params4: 发送消息的内容
channel.basicPublish("", "queue1", null, msg.getBytes());
}
System.out.println("消息发送成功!");
} catch (Exception ex) {
ex.printStackTrace();
System.out.println("发送消息出现异常...");
} finally {
// 7: 释放连接关闭通道
if (channel != null && channel.isOpen()) {
try {
channel.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
}
}
work1
package com.tian.rabbitmq.work.fair;
import com.rabbitmq.client.*;
import java.io.IOException;
/**
* @author: 学相伴-飞哥
* @description: Consumer
* @Date : 2021/3/2
*/
public class Work1 {
public static void main(String[] args) {
// 1: 创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
// 2: 设置连接属性
connectionFactory.setHost("192.168.1.150");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
Connection connection = null;
Channel channel = null;
try {
// 3: 从连接工厂中获取连接
connection = connectionFactory.newConnection("消费者-Work1");
// 4: 从连接中获取通道channel
channel = connection.createChannel();
final Channel finalChannel = channel;
finalChannel.basicQos(1);
finalChannel.basicConsume("queue1", false, new DeliverCallback() {
public void handle(String s, Delivery delivery) throws IOException {
try{
System.out.println("Work1-收到消息是：" + new String(delivery.getBody(), "UTF-8"));
Thread.sleep(2000);
finalChannel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
}catch(Exception ex){
ex.printStackTrace();
}
}
}, new CancelCallback() {
public void handle(String s) throws IOException {
}
});
System.out.println("Work1-开始接受消息");
System.in.read();
} catch (Exception ex) {
ex.printStackTrace();
System.out.println("发送消息出现异常...");
} finally {
// 7: 释放连接关闭通道
if (channel != null && channel.isOpen()) {
try {
channel.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
if (connection != null && connection.isOpen()) {
try {
connection.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
}
}
work2
package com.tian.rabbitmq.work.fair;
import com.rabbitmq.client.*;
import java.io.IOException;
/**
* @author: 学相伴-飞哥
* @description: Consumer
* @Date : 2021/3/2
*/
public class Work2 {
public static void main(String[] args) {
// 1: 创建连接工厂
ConnectionFactory connectionFactory = new ConnectionFactory();
// 2: 设置连接属性
connectionFactory.setHost("192.168.1.150");
connectionFactory.setPort(5672);
connectionFactory.setVirtualHost("/");
connectionFactory.setUsername("admin");
connectionFactory.setPassword("admin");
Connection connection = null;
Channel channel = null;
try {
// 3: 从连接工厂中获取连接
connection = connectionFactory.newConnection("消费者-Work2");
// 4: 从连接中获取通道channel
channel = connection.createChannel();
// 5: 申明队列queue存储消息
/*
* 如果队列不存在，则会创建
* Rabbitmq不允许创建两个相同的队列名称，否则会报错。
*
* @params1： queue 队列的名称
* @params2： durable 队列是否持久化
* @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
* @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
* @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
* */
// 这里如果queue已经被创建过一次了，可以不需要定义
//channel.queueDeclare("queue1", false, true, false, null);
// 同一时刻，服务器只会推送一条消息给消费者
//channel.basicQos(1);
// 6： 定义接受消息的回调
final Channel finalChannel = channel;
finalChannel.basicQos(1);
finalChannel.basicConsume("queue1", false, new DeliverCallback() {
@Override
public void handle(String s, Delivery delivery) throws IOException {
try{
System.out.println("Work2-收到消息是：" + new String(delivery.getBody(), "UTF-8"));
Thread.sleep(200);
finalChannel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
}catch(Exception ex){
ex.printStackTrace();
}
}
}, new CancelCallback() {
@Override
public void handle(String s) throws IOException {
}
});
System.out.println("Work2-开始接受消息");
System.in.read();
} catch (Exception ex) {
ex.printStackTrace();
System.out.println("发送消息出现异常...");
} finally {
// 7: 释放连接关闭通道
if (channel != null && channel.isOpen()) {
try {
channel.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
if (connection != null && connection.isOpen()) {
try {
connection.close();
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
}
}
先运行work1 work2 在运行producer 现象 work处理的消息比较多
MQ的使用场景
- 串行执行
代码
public void makeOrder(){
//1.保存订单
orderService.saveOrder();
//2.发送短信服务
messageService.sendSMS("order");
//3.发送Email服务
emailService.sendEmail("order");
//4.发送App服务
appService.sendApp("order");
}
- 并行
代码
public void makeOrder(){
//1:保存订单
orderService.saveOrder();
//相关发送
relationMessage();
}
public void relationMessage(){
//异步
theadpool.submit(new Callable<Object>{
public object call(){
//发送短信服务
messageService.sendSMS("order");
}
})
//异步
theadpool.submit(new Callable<Object>{
public object call(){
//3.发送Email服务
emailService.sendEmail("order");
}
})
}
- 异步消息队列
代码
public void makeOrder(){
//1:保存订单
orderService.saveOrder();
rabbitTemplate.convertSend("ex","2","消息内容");
}
解耦
扫一扫
245
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
