rabbitmq---安装，学习（七种消息模型）

最新推荐文章于 2020-12-25 20:29:18 发布
最新推荐文章于 2020-12-25 20:29:18 发布
阅读量325 收藏
点赞数
分类专栏： Rabbitmq 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Actor2/article/details/111502158
版权

在这里插入图片描述

rpm -ivh erlang-23.1.5-1.el7.x86_64.rpm //安装erlang包，https://github.com/rabbitmq/erlang-rpm
rpm -ivh rabbitmq-server-3.8.9-1.el7.noarch.rpm //安装rabbitmq-server，https://www.rabbitmq.com/install-rpm.html#downloads

结果报错了

[root@localhost ~]# rpm -ivh rabbitmq-server-3.8.9-1.el7.noarch.rpm 
warning: rabbitmq-server-3.8.9-1.el7.noarch.rpm: Header V4 RSA/SHA256 Signature, key ID 6026dfca: NOKEY
error: Failed dependencies:
	socat is needed by rabbitmq-server-3.8.9-1.el7.noarch

少了一个socat的管理包，我们在线安装一个

yum install socat

再次安装rabbitmq-server，安装成功

systemctl status rabbitmq-server//查看rabbitmq的状态
systemctl start rabbitmq-server//启动rabbitmq服务
systemctl restart rabbitmq-server//重新启动rabbitmq服务
systemctl stop rabbitmq-server//停止rabbitmq服务

现在3.8.9版本在/etc/rabbitmq是没有配置文件的，而且安装包里面也没有自带配置文件模板，而如果想登录web管理界面，我们需要开启默认用户guest

vim /etc/rabbitmq/rabbitmq.conf

##粘贴以下内容，该配置文件是网上找的，保存后重新启动
loopback_users.guest = false
cluster_formation.peer_discovery_backend  = rabbit_peer_discovery_consul
cluster_formation.consul.host = consul
cluster_formation.node_cleanup.only_log_warning = false
cluster_formation.consul.svc_addr_auto = true
cluster_partition_handling = autoheal
vm_memory_high_watermark.relative = 0.8

开启管理界面

rabbitmq-plugins enable rabbitmq_management

记得关闭防火墙或者开启端口15672

然后就可以打开web界面了，输入账号密码guest进入管理界面
在这里插入图片描述

AMQP协议

AMQP协议

AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现有RabbitMQ等。

模型

在这里插入图片描述

在rabbitmq里面是有交换机的概念的，消息发送到交换机，队列绑定交换机，然后消费者绑定队列进行消费

其中的virtual是虚拟主机的意思，就是为了多个项目进行区分，每一个项目创建一个virtual自己使用

7种模型

在这里插入图片描述

引入客户端依赖

<!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.10.0</version>
</dependency>

//工具类
public class RabbitMQUtils {
    private static ConnectionFactory factory;

    static {
        //创建工厂
        factory = new ConnectionFactory();
        //设置主机
        factory.setHost("192.168.137.100");
        //设置端口号
        factory.setPort(5672);
        //设置连接的主机
        factory.setVirtualHost("/mes");
        //设置用户
        factory.setUsername("guest");
        //设置密码
        factory.setPassword("guest");
    }
	//获取连接
    public static Connection getConnection() {

        try {
            //获取连接
            Connection connection = factory.newConnection();
            return connection;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        return null;
    }
	//关闭连接
    public static void close(Channel channel, Connection connection) {
        try {
            channel.close();
            connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

helloword（直连）

//消息生产者
@Test
void helloProvider() throws IOException, TimeoutException {
    Connection connection = RabbitMQUtils.getConnection();

        //获取通道
        Channel channel = connection.createChannel();

        //通道绑定队列
        //参数1：队列名称，不存在会自动创建
        //参数2：队列是否持久化
        //参数3：是否独占队列（是否允许其他连接可用） true独占 false不独占
        //参数4：是否在消息消费完后自动删除
        //参数5：附加参数
        channel.queueDeclare("hello", false, false, false, null);

        //发布消息
        //参数1：交换机名称
        //参数2：队列名称
        //参数3：额外设置
        //参数4：消息内容，必须为字节数组
        channel.basicPublish("", "hello", null, "这是hello".getBytes());

        RabbitMQUtils.close(channel,connection);
}

在这里插入图片描述

发现消息发布成功

//消息消费
public class HelloConsumer {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        //获取通道
        Channel channel = connection.createChannel();
        channel.queueDeclare("hello",false,false,false,null);

        //参数1:队列名称
        //参数2:是否消息确认
        //参数3:消费回调
        channel.basicConsume("hello",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消息内容为:"+new String(body));
            }
        });
        //RabbitMQUtils.close(channel,connection);//如果关掉连接的话，程序就直接结束了，不会再监听队列
    }
}

hello模型是最简单的消息模型，是一对一的，一个生产者对应一个队列对应一个消费者

work queue （任务）

在第一种模型（helloworld）之上，如果每一个消息在消费的时候如果处理时间过程，队列中消息越来越多，会导致消息不及时消费，造成很多问题，所以有了work queue（任务）的消息模型，这种消息模型就是多个消费者消费同一个队列里面的消息，消息不会被多次消费

//生产者
public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();

        //获取通道
        Channel channel = connection.createChannel();

        //通道绑定队列
        //参数1：队列名称，不存在会自动创建
        //参数2：队列是否持久化
        //参数3：是否独占队列（是否允许其他连接可用） true独占 false不独占
        //参数4：是否在消息消费完后自动删除
        //参数5：附加参数
        channel.queueDeclare("work", false, false, false, null);

        for (int i = 1; i <= 10; i++) {
            //发布消息
            //参数1：交换机名称
            //参数2：队列名称
            //参数3：额外设置
            //参数4：消息内容，必须为字节数组
            channel.basicPublish("", "work", null, ("这是work"+i+"").getBytes());
        }

        RabbitMQUtils.close(channel,connection);
    }
}

//消费者2
public class WorkConsumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        //获取通道
        Channel channel = connection.createChannel();
        channel.queueDeclare("work",false,false,false,null);

        //参数1:队列名称
        //参数2:是否消息确认
        //参数3:消费回调
        channel.basicConsume("work",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("work模型消费者1:"+new String(body));
            }
        });
    }
}

//消费者2
public class WorkConsumer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        //获取通道
        Channel channel = connection.createChannel();
        channel.queueDeclare("work",false,false,false,null);

        //参数1:队列名称
        //参数2:是否消息确认
        //参数3:消费回调
        channel.basicConsume("work",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("work模型消费者2:"+new String(body));
            }
        });
    }
}

这种默认是平均消费，也就是如果10条消息的话，也就是两个消费者都消费5条消息，这样肯定也有问题，要是有一个消费者卡顿了，处理一个消息需要5秒钟，这样的话总体消费消息的时间还是很久，不科学，如果每个消费者消费完了一条消息就去队列里面继续消费消息就好了，也就是能者多劳

能者多劳

生产者不变，消费者开启手动确认，每次消费一个

//消费者1
public class WorkConsumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        //获取通道
        Channel channel = connection.createChannel();

        //每次消费多少个消息（1）
        channel.basicQos(1);

        channel.queueDeclare("work",false,false,false,null);

        //参数1:队列名称
        //参数2:是否自动消息确认（2）
        //参数3:消费回调
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("work模型消费者1:"+new String(body));

                 //(3)
                //手动确认
                //确认标识
                //是否开启多个消息自动确认
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

//消费者2
public class WorkConsumer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        //获取通道
        Channel channel = connection.createChannel();

        //每次消费多少个消息（1）
        channel.basicQos(1);

        channel.queueDeclare("work",false,false,false,null);

        //参数1:队列名称
        //参数2:是否自动消息确认（2）
        //参数3:消费回调
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("work模型消费者2:"+new String(body));
                
                //(3)
                //手动确认
                //确认标识
                //是否开启多个消息自动确认
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

1：设置每次消费1个消息

2：开启手动确认消息

3，消费关闭手动确认

fanout （广播）

生产者把消息发送给交换机，在由交换机发送给各个订阅的队列（一个队列对应一个消费者），在由消费者消费，这种很消息模型还是比较常见的，比如说微信的订阅号，你订阅过后，就相当于队列订阅了交换机，然后生产者给交换机发送消息时，交换机就会给所有订阅他的队列发送消息

//生产者
public class FanoutProvider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();

        //获取通道
        Channel channel = connection.createChannel();

        //申明交换机
        //参数1：交换机名称
        //参数2：交换机类型
        channel.exchangeDeclare("fanout","fanout");

        //发送消息
        //参数1：交换机名称
        //参数2：路由key
        //参数3：消息持久化
        //参数4：消息内容
        channel.basicPublish("fanout","",null,"这是fanout类型".getBytes());

        RabbitMQUtils.close(channel,connection);
    }
}

//消费者1
public class FanoutConsumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare("fanout","fanout");

        //临时队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定交换机和队列
        channel.queueBind(queueName,"fanout","");

        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("fanout的消费者1,消息内容为："+new String(body));
            }
        });
    }
}

//消费者2
public class FanoutConsumer3 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare("fanout","fanout");

        //临时队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定交换机和队列
        channel.queueBind(queueName,"fanout","");

        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("fanout的消费者2,消息内容为："+new String(body));
            }
        });
    }
}

//消费者3
public class FanoutConsumer3 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare("fanout","fanout");

        //临时队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定交换机和队列
        channel.queueBind(queueName,"fanout","");

        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("fanout的消费者3,消息内容为："+new String(body));
            }
        });
    }
}

在fanout的消息模型中是没有用到路由key的，所有在发送消息时路由key为空

Routing （路由）

路由，就是可以按照路由key来匹配，确定要发送的队列，在有时候有些消息需要全部的消费者消费，有时候需要一部分消费者消费

//生产者
public class RoutingProvider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("direct","direct");
        channel.basicPublish("direct","blue",null,"direct消息模型".getBytes());
        RabbitMQUtils.close(channel,connection);
    }
}

//消费者1
public class RoutingConsumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("direct","direct");

        String queue = channel.queueDeclare().getQueue();

        channel.queueBind(queue,"direct","red");

        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("这里只接受red，消息内容为："+new String(body));
            }
        });
    }
}

//消费2
public class RoutingConsumer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("direct","direct");

        String queue = channel.queueDeclare().getQueue();

        channel.queueBind(queue,"direct","blue");

        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("这里只接受blue，消息内容为："+new String(body));
            }
        });
    }
}

//消费3
public class RoutingConsumer3 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("direct","direct");

        String queue = channel.queueDeclare().getQueue();

        channel.queueBind(queue,"direct","red");
        channel.queueBind(queue,"direct","blue");


        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("这里只接受red和blue，消息内容为："+new String(body));
            }
        });
    }
}

当生产者发送消息，路由key为：red时，消费者1和消费者3会消费，因为消费者2是绑定的blue的路由key

当生产者发送消息，路由key为：blue时，消费者2和消费者3会消费，因为消费者1是绑定的red的路由key

Topics （动态路由）

在路由的消息模型之上，允许key使用通配符，这样就可以更加的灵活

//生产者
public class TopicsProvider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare("topics","topic");
        channel.basicPublish("topics","green.blue.green",null,"topics消息模型".getBytes());
        RabbitMQUtils.close(channel,connection);
    }
}

//消费者1
public class TopicsConsumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("topics","topic");

        String queue = channel.queueDeclare().getQueue();
        channel.queueBind(queue,"topics","red.*");
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费red开头的，不关心后续内容，消息内容为："+new String(body) );
            }
        });
    }
}

//消费者2
public class TopicsConsumer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("topics","topic");

        String queue = channel.queueDeclare().getQueue();
        channel.queueBind(queue,"topics","*.blue.*");
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费blue为中间的，不关心前后内容，消息内容为："+new String(body) );
            }
        });
    }
}

*:代表一个单词，可以为任何单词，但是不能为空，不然匹配不到

#:代表任何，可以有，可以没有，也就是代表0到多个单词

你是我的小毛驴
关注
专栏目录
@kafkalistener消费不到消息_分布式事务解决方案之可靠消息最终一致性+最大努力通知...
weixin_30007303的博客
12-28 814
可靠消息最终一致性此方案利用消息中间件完成，事务发起方(生产者)将消息发给中间件，事务参与方(消费者)从消息中间件中获取消息。事务发起方与中间件，事务参与方与中间件之间都是由网络连接的，由于网络的不确定性，引起了分布式事务问题。因此，消息可靠最终一致性方案需要解决如下问题：本地事务与消息发送的原子性问题：即只要本地事务执行完成，消息到达中间件有一定要完成。事务参与方接受消息可靠性：事务参与者可以从...
从message.properties获取消息代码列表
03-31 1463
通常，通过键（即消息代码）从消息属性中获取消息，如果我们想选择多个消息属性（如列表），该怎么办。 要从message.properties获取选择消息代码的列表，我们需要自定义messageSource bean。 为此，让我们创建一个“ CustomizedPluginAwareResourceBundleMessageSource”类，该类应该扩展“ PluginAwareResourc...
SpringBoot整合 RabbitMQ
我的博客
09-08 950
SpringBoot整合 RabbitMQ 建springboot项目时导入springboot整合rabbitmq依赖包 1,生产者 application.yml配置文件 spring: rabbitmq: port: 5672 password: root username: root virtual-host: /pms host: localhost template: mandatory: true #没有投递到队列，强
17 个方面，综合对比 Kafka、RabbitMQ、RocketMQ、ActiveMQ 四个分布式消息队列
程序员闪充宝
01-14 361
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达作者：28cm不含头来源：http://t.cn/RVDWcfe本文将从，Kafka、RabbitMQ、ZeroMQ、Rocke...
Kafka设计解析（五）：Kafka Benchmark
weixin_33982670的博客
01-29 147
为什么80%的码农都做不了架构师？>>> ...
rabbitmq-java (2).zip
01-11
RabbitMQ是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，被广泛用于处理分布式系统中的异步任务和消息传递。在这个名为"rabbitmq-java (2).zip"的压缩包中，我们可以看到...
rabbitMQ-demo.zip_DEMO_piguhw_rabbitMQ-demo_rabbitmq .idx
09-19
RabbitMQ 采用推送模型，当队列中有新消息时，它会主动推送给消费者。 7. **确认机制（Acknowledgements）**：RabbitMQ 提供了消息确认机制，确保消息被正确处理。消费者在处理完消息后发送确认，RabbitMQ 收到确认...
rabbitmq-server-windows-3.6.10.zip
06-24
7. **消息模型**：RabbitMQ支持多种消息模型，如Direct、Fanout、Topic和Header，可以根据你的应用场景选择合适的模型。 8. **监控与日志**：RabbitMQ提供了丰富的监控工具和日志记录，可以帮助你了解系统的运行...
rabbitmq-server-windows-3.6.16.zip
03-05
在Windows环境中安装和运行RabbitMQ，开发者可以利用其功能在Windows服务中实现消息队列的管理和服务。 标签"rabbimqwindows"是RabbitMQ与Windows操作系统的组合关键词，便于搜索和识别。 在压缩包"rabbitmq_...
rabbitmq-server-3.9.14
05-04
1. **AMQP协议**：AMQP是一种开放标准，定义了消息传递的通用模型，包括交换机、队列、绑定和消息属性等概念。RabbitMQ作为AMQP的实现，允许开发者在不同系统间通过消息传递进行通信，确保解耦和可靠的数据传输。 2...
MessageResources_zh_CN.properties
12-22
MessageResources_zh_CN.properties
用Kafka自带脚本实现Kafka消费情况实时监控
ChengYanan的博客
06-05 2302
查看consumer组内消费的offset 在${KAFKA_HOME}/bin下 ./kafka-run-class.sh kafka.tools.ConsumerOffsetChecker --zookeeper host:2181 --group [消费者组名] --topic [topic名] 其中的group可去zookeeper中查看： [hadoop@h71 zookeeper-3....
unipush解决华为、小米、魅族收不到厂商推送的问题
jinguo888的专栏
09-08 3184
保证厂商推送设置AppID，AppKey，AppSecret正确 在uniapp程序入口加入以下代码： var pinf = plus.push.getClientInfo(); var cid = pinf.clientid;//客户端标识 console.log('cid=='+cid) plus.push.addEventListener("receive", function(msg) { if ( ms
kafka基本概念详解
古川熊灰的博客
09-16 361
文章目录kakfa消息队列为什么要使用消息队列消息队列的两种实现模式Kafka是一个分布式的、可分区的、可复制的消息系统。客户端和服务端通过TCP协议通信。zookeeper在kafka的作用：概念详解：topic,broker,partition之间的关系leader选举规则消费者组分区作用数据存放分区确定原则事务级别工作流程生产写入步骤（ack为all时）ack机制存储存储策略zookeeper存储信息消费API kakfa 消息队列 为什么要使用消息队列 通常的消息传输，生产者和消费者之间需要同步，
Properties文件读取 Message.properties
yuxiangjiuxiao的博客
11-08 2084
Message.propertiesmsg_id:msg1msg_01:00001msg_02:00002msg_03:00003err_01:e0001err_02:e0002err_03:e0003
RabbitMQ简介、概念、安装、启动、工作模式
我的博客
09-07 584
RabbitMQ简介、概念、安装、启动、工作模式 1、RabbitMQ简介 RabbitMQ是支持多种消息协议，易于部署和使用的开源消息代理服务器，用于在分布式系统中存储转发消息 由以高性能、健壮以及可伸缩性出名的Erlang语言编写；提供了成熟的高并发，高可用的解决方案 可以根据实际业务情况动态地扩展集群节点在集群中的机器上设置镜像，使得在部分节点出现问题的情况下仍然可用 支持多种客户端语言，如：Python、Ruby、.NET、Java等，支持AJAX RabbitMQ提供了一个易用的用户界面，使得
@kafkalistener消费不到消息_KAFKA的消费时OFFSET管理
weixin_32946431的博客
12-25 2873
基本概念介绍topic消息队列partitiontopic下的存储单元，类似分片(sharding)，每个partition对应一个实体文件offsetpartition内每条消息的ID，单个partition内递增brokerkafka集群的节点，负责存储消息，也是生产消费消息的接入点consumer_group消费组。同一消费组对应的同一topic的下同一个partition只有一个...
Kafka设计解析（五）- Kafka性能测试方法及Benchmark报告
技术世界
01-04 1864
本文详细阐述了Kafka的性能测试方法，并全面展示了Kafka各组件的性能测试报告。
RabbitMq延迟消息队列死信队列实现定时任务 --菜鸟小回
菜鸟小回的博客
09-10 1434
延迟消息队列 TradeProcess @Service public class TradeProcess { @Autowired private AmqpTemplate amqpTemplate; @RabbitListener(queues= MqConstant.MY_TRANS_QUEUE) @RabbitHandler public void process(String content) { String msg = cont
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值