RabbitMQ从Linux安装到springboot入门整合常见模式

已于 2022-08-04 15:47:58 修改
阅读量1.4k 收藏
点赞数
分类专栏： 消息队列 文章标签： linux rabbitmq java
于 2021-11-29 10:01:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hrd535523596/article/details/121602807
版权

下载安装的环境为centos7，并未写明如何上传文件到Linux虚拟机中，相信能学到MQ的朋友们都应该多少了解过如何上传文件，虽然我本人习惯用lrzsz的方式。java整合使用rabbitmq分别有非注解和注解两种风格。

文章目录

RabbitMQ安装

安装依赖环境

在线安装依赖环境：

yum install build-essential openssl openssl-devel unixODBC unixODBC-devel make gcc gcc-c++ kernel-devel m4 ncurses-devel tk tc xz

安装Erlang

上传
erlang-18.3-1.el7.centos.x86_64.rpm
socat-1.7.3.2-1.1.el7.x86_64.rpm
rabbitmq-server-3.6.5-1.noarch.rpm

在这里插入图片描述

# 安装
rpm -ivh erlang-18.3-1.el7.centos.x86_64.rpm

安装RabbitMQ

# 安装
rpm -ivh socat-1.7.3.2-5.el7.lux.x86_64.rpm
# 安装
rpm -ivh rabbitmq-server-3.6.5-1.noarch.rpm

开启管理界面及配置

# 开启管理界面
rabbitmq-plugins enable rabbitmq_management
# 修改默认配置信息
vim /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.5/ebin/rabbit.app 
# 比如修改密码、配置等等，例如：loopback_users 中的 <<"guest">>,只保留guest

启动

service rabbitmq-server start # 启动服务
service rabbitmq-server stop # 停止服务
service rabbitmq-server restart # 重启服务
  • 设置配置文件
cd /usr/share/doc/rabbitmq-server-3.6.5/
cp rabbitmq.config.example /etc/rabbitmq/rabbitmq.config

在这里插入图片描述

配置虚拟主机及用户

RabbitMQ在安装好后，可以访问http://ip地址:15672 ；其自带了guest/guest的用户名和密码；如果需要创建自定义用户；那么也可以登录管理界面后，如下操作：
在这里插入图片描述
在这里插入图片描述

Virtual Hosts配置

在这里插入图片描述

设置Virtual Hosts权限

在这里插入图片描述
在这里插入图片描述

Spring Boot整合RabbitMQ

生产者

配置文件：application.yml

spring:
  rabbitmq:
    host: 192.168.96.133
    port: 5672
    username: hrd
    password: hrd
    virtual-host: /test

配置@Configuration类：config.rabbitMQConfig.java

package com.example.producerboot.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class rabbitMQConfig {
    public static final String EXCHANGE_NAME="boot_topic_exchange";
    public static final String QUEUE_NAME="boot_topic_change";

//    1.交换机
    @Bean("bootExchange")
    public Exchange bootExchange(){
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }
//    2.队列
    @Bean("bootQueue")
    public Queue bootQueue(){
        return QueueBuilder.durable(QUEUE_NAME).build();
    }
//    3.队列和交换机绑定 Bingding
//        知道哪个队列->知道哪个交换机->知道哪个routing key
//    @Qualifier注入对应名字的队列和交换机
    @Bean
    public Binding bingQueueExchange(@Qualifier("bootQueue") Queue queue,@Qualifier("bootExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    }
}

测试Test类：ProducerBootApplicationTests.java

RabbitTemplate类模板，简化操作，使用时需要注入

package com.example.producerboot;

import com.example.producerboot.config.rabbitMQConfig;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class ProducerBootApplicationTests {
//    1.注入rabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void contextLoads() {
        rabbitTemplate.convertAndSend(rabbitMQConfig.EXCHANGE_NAME,"boot.haha","boot mq hello~");
    }

}

消费者

maven中pom.xml文件依赖和application.yml配置文件内容与生产者一样
在这里插入图片描述
消费者测试代码：

package com.example.consumerboot;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class rabbitMQListener {

    @RabbitListener(queues = "boot_topic_change")
    public void listenerQueue(Message message){
        System.out.println(message);
    }
}

工作模式

工作队列模式

在这里插入图片描述
特征：多个消费端共同消费同一个队列中的消息

应用：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

小结：

  1. 在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。

2. Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个，

只需要有一个节点成功发送即可。

生产者测试代码：

package com;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class helloWorld {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.96.133");
        factory.setPort(5672);
        factory.setVirtualHost("/test");
        factory.setUsername("hrd");
        factory.setPassword("hrd");
        //3.创建连接
        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);
        //需要传递的消息内容
        String body = "hello rabbitmq~~~";
        //6.发送消息
        /*
        basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
        参数：
            1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
            2. routingKey：路由名称
            3. props：配置信息
            4. body：发送消息数据

         */
        channel.basicPublish("","hello_world",null,body.getBytes());
        //7.释放资源
        channel.close();
        connection.close();
    }

}

消费者测试代码：

package com;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class helloWorld {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.96.133");
        factory.setPort(5672);
        factory.setVirtualHost("/test");
        factory.setUsername("hrd");
        factory.setPassword("hrd");
        //3.创建连接
        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);

        //6.接收消息
        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 {
//                super.handleDelivery(consumerTag, envelope, properties, body);
                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));
            }
        };
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        参数：
            1. queue：队列名称
            2. autoAck：是否自动确认
            3. callback：回调对象
         */
        channel.basicConsume("hello_world",true,consumer);

    }

}

订阅模式Fanout

在这里插入图片描述
特征：多了一个 Exchange 角色

应用：

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与 Exchange 绑定，或者没有符合

路由规则的队列，那么消息会丢失！

Exchange有常见以下3种类型：

​ ➢ Fanout：广播，将消息交给所有绑定到交换机的队列

​ ➢ Direct：定向，把消息交给符合指定routing key 的队列

​ ➢ Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列
在这里插入图片描述
小节：

交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。

发布订阅模式与工作队列模式的区别：

  1. 工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机

  2. 发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用

    默认交换机)

  3. 发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队

    列绑 定到默认的交换机

生产者测试代码：

package com;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

//生成者p
public class pubSub {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.96.133");
        factory.setPort(5672);
        factory.setVirtualHost("/test");
        factory.setUsername("hrd");
        factory.setPassword("hrd");
        //3.创建连接
        Connection connection = factory.newConnection();
        //4.设置channel
        Channel channel = connection.createChannel();
        //5. 创建交换机
        /*
       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";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
        //6.创建队列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的队列，则会创建该队列，如果有则不会创建
        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,"");
        //8.发送消息
        /*
        basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
        参数：
            1. exchange：交换机名称。简单模式下交换机会使用默认的 ""
            2. routingKey：路由名称
            3. props：配置信息
            4. body：发送消息数据

         */
        //需要传递的消息内容
        String body = "hello rabbitmq~~~";
        channel.basicPublish(exchangeName,"",null,body.getBytes());

        //9.释放资源
        channel.close();
        connection.close();
    }

}

生产者测试截图：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
消费者测试代码：

package com;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class pubSub2 {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.96.133");
        factory.setPort(5672);
        factory.setVirtualHost("/test");
        factory.setUsername("hrd");
        factory.setPassword("hrd");
        //3.创建连接
        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的队列，则会创建该队列，如果有则不会创建
        //由于先执行生产者，则已经创建，不需要重复
        String queue1Name = "test_fanout_queue1";
        String queue2Name = "test_fanout_queue2";
//        channel.queueDeclare(queue1Name,true,false,false,null);

        //6.接收消息
        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 {
//                super.handleDelivery(consumerTag, envelope, properties, body);
//                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));
            }
        };
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        参数：
            1. queue：队列名称
            2. autoAck：是否自动确认
            3. callback：回调对象
         */
        channel.basicConsume(queue2Name,true,consumer);
    }
}

消费者测试截图：
在这里插入图片描述

路由模式Direct

说明：

  1. 队列与交换机的绑定，不能是任意绑定了，而是要指定一个 RoutingKey（路由key）

  2. 消息的发送方在向 Exchange 发送消息时，也必须指定消息的 RoutingKey

  3. Exchange 不再把消息交给每一个绑定的队列，而是根据消息的 Routing Key 进行判断，只有队列的Routingkey 与消息的 Routing key 完全一致，才会接收到消息

小结：

Routing 模式要求队列在绑定交换机时要指定 routing key，消息会转发到符合 routing key 的队列。
在这里插入图片描述
在这里插入图片描述
截图为原生非注解代码

以下是使用注解生产者

@Autowired
private RabbitTemplate rabbitTemplate;

@Test
public void testDirect(){
    rabbitTemplate.convertAndSend("directs","error","error 的日志信息");
}

使用注解消费者

@Component
public class DirectCustomer {

    @RabbitListener(bindings ={
        @QueueBinding(
            value = @Queue(), key={"info","error"},
            exchange = @Exchange(type = "direct",name="directs")
        )})
    public void receive1(String message){
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings ={
        @QueueBinding(
            value = @Queue(), key={"error"},
            exchange = @Exchange(type = "direct",name="directs")
        )})
    public void receive2(String message){
        System.out.println("message2 = " + message);
    }
}

通配符模式Topics

说明：

  1. Topic 类型与 Direct 相比，都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型Exchange 可以让队列在绑定 Routing key 的时候使用通配符！

  2. Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

  3. 通配符规则：

    #匹配一个或多个词， 匹配不多不少恰好1个词*

    例如：item.# 能够匹配 item.insert.abc 或者 item.insert，item.* 只能匹配 item.insert
    在这里插入图片描述
    生产者

@Autowired
private RabbitTemplate rabbitTemplate;

//topic
@Test
public void testTopic(){
  rabbitTemplate.convertAndSend("topics","user.save.findAll","user.save.findAll 的消息");
}

消费者

@Component
public class TopCustomer {
    @RabbitListener(bindings = {
        @QueueBinding(
            value = @Queue, key = {"user.*"},
            exchange = @Exchange(type = "topic",name = "topics")
        )
    })
    public void receive1(String message){
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = {
        @QueueBinding(
            value = @Queue, key = {"user.#"},
            exchange = @Exchange(type = "topic",name = "topics")
        )
    })
    public void receive2(String message){
        System.out.println("message2 = " + message);
    }
}

高级特性

待续后期系统学习整理~

丶di
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMq 虚拟主机 virtual-host ，Springboot 中使用 RabbitMq 虚拟主机 virtual-host
简简单单Onlinezuozuo
12-20 2万+
文章目录RabbitMq 虚拟主机 virtual-host ，Springboot 中使用 RabbitMq 虚拟主机 virtual-host1、在RabbitMQ 控制台中创建虚拟主机2、创建一个用户3、把用户分配给虚拟主机4、在Springboot 项目中指定连接时，连接到指定的虚拟主机5、虚拟主机在Springboot 中取值的源码 RabbitMq 虚拟主机 virtual-host ...
Spring Boot 整合 RabbitMQ 教程。
不受天磨非好汉，不遭人妒是庸才——着实着迷゛
10-17 243
一：安装 RabbitMQ 服务（linux docker容器方式安装） 查看服务器已经下载的docker镜像 [root@localhost ~]# docker images 还没有 rabbitmq 的镜像 去 https://hub.docker.com 镜像官网搜索 rabbitmq 的镜像 我们这里选择 以management结尾的tag 的镜像 使用dock...
Springboot 监听同一个RabbitMQ的多个虚拟主机Virtual-Host
Bejpse的博客
04-26 1670
目录 配置信息application.properties 配置类RabbitMqConfig 监听消息示例 场景：需要监听 同一个RabbitMQ下的 不同的虚拟主机下的 队列 来完成数据流转 配置信息application.properties my.rabbitmq.host=你的ip my.rabbitmq.port=你的port my.rabbitmq.username=你的username my.rabbitmq.password=你的password my.rabbitmq.first
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4607
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
RabbitMQ管理界面说明
多学"亿"点的博客
11-11 2108
1、 RabbitMQ管理界面说明 connections：无论生产者还是消费者，都需要与RabbitMQ建立连接后才可以完成消息的生产和消费，在这里可以查看连接情况 channels：通道，建立连接后，会形成通道，消息的投递获取依赖通道。 Exchanges：交换机，用来实现消息的路由 Queues：队列，即消息队列，消息存放在队列中，等待消费，消费后被移除队列。 2、Admin用户和虚拟主机管理 上面的Tags选项，其实是指定用户的角色，可选的有以下几个： 超级管理员(adm
RabbitMQ安装与springboot整合RabbitMQ
01-07
RabbitMQ安装 docker hub进入仓库拉镜像数据，链接：https://hub.docker.com 进入tag标签下，找到带有management的，这个是带有web管理界面的。 下载较慢可以是用加速。 docker pull registry.docker-...
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
RabbitMQ Linux安装教程
最新发布
06-09
RabbitMQ的安装过程在Linux环境下需要依赖于Erlang，而Erlang自身又依赖于某些库，如wxWidgets。以下是详细的安装步骤： 1. **wxWidgets**： - wxWidgets是一个C++库，用于开发图形用户界面，它是Erlang的依赖之一...
rabbitMQ概述/在springboot下测试五种模式
weixin_44773418的博客
08-01 346
一、应用场景： (1) 异步操作: 任务异步处理将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。 (2) 解耦: 应用程序解耦合MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合 (3) 削峰: 在访问量剧增的情况下，应用仍然需要继续发挥作用，但是这样的突发流量并不常见；如果为以能处理这类峰值访问为标准来投入资源随时待命无疑是巨...
RabbitMQ & SpringBoot 快速入门
weixin_34099526的博客
06-24 230
MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取队列中的消息。消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不...
springboot整合RabbitMq+linux搭建（附工具类）
Mascotto_li的博客
04-07 532
Rabbitmq（Linux+springboot）附工具类@TOC 最近用到了rabbitmq，搭配过程中也遇到了一些问题，现在总结一下 先来做个对比 各种消息中间件性能的比较： TPS比较 一ZeroMq 最好，RabbitMq 次之， ActiveMq 最差。 持久化消息比较—zeroMq不支持，activeMq和rabbitMq都支持。持久化消息主要是指：MQ down或者MQ所在的服务器...
linux-rabbitmq集群部署及springboot结合
zhuchunyan_aijia的博客
05-08 2991
https://blog.csdn.net/a491857321/article/details/52814045//RabbitMQ单机spring:  rabbitmq:    host: localhost    port: 5672    username: your_username    password: your_password//或者  RabbitMQ单机，只使用addres...
Spring Boot整合RabbitMQ详细教程
热门推荐
你好，我们在哪里见过啊！
05-14 18万+
1.首先我们简单了解一下消息中间件的应用场景 异步处理 场景说明：用户注册后，需要发注册邮件和注册短信,传统的做法有两种1.串行的方式;2.并行的方式 (1)串行方式:将注册信息写入数据库后,发送注册邮件,再发送注册短信,以上三个任务全部完成后才返回给客户端。 这有一个问题是,邮件,短信并不是必须的,它只是一个通知,而这种做法让客户端等待没有必要等待的东西. (2)并行方式:将注册信...
linux安装rabbitmq_springcloud——rabbitmq
weixin_39914938的博客
11-26 61
什么是 RabbitMQ安装rabbitmq（linux系统，<win系统管网下载exe文件进行安装即可>）首先要更新wgetsudo yum -y install wget安装OpenSSL环境wget ftp://ftp.openssl.org/source/openss-1.0.0c.tar.gztar -zxv openssl-1.0.0c.tar.gzcd openssl-1...
linux下安装rabbitmq以及在spring中进行集成
weixin_30561425的博客
09-06 86
### 一、安装erlang 1. yum install ncurses-devel 2. ./configure --prefix=/usr/local/erlang20 --without-javac 3. make&&makeinstall ### 二、安装RabblitMQ 1. 安装Python：yum install python -y 2. 安装s...
Spring Boot 整合rabbitmq
Dream_it_possible！的博客
03-04 1231
一、队列准备 1. 先进入到rabbitmq的管理页面，然后在管理页面新建一个虚拟主机，默认的虚拟主机为"/" ,不同的环境使用不同的虚拟主机，如开发环境可以设置为dev,生产环境可以设置为prod。 2. 在默认的虚拟主机下，新增一个队列rabbitmqtest 二、实现步骤 1. 添加rabbitmq依赖 ： ...
RabbitMQ超简教程：从入门到SpringBoot整合
"RabbitMQ.pdf 是一份超简明教程，涵盖了消息队列的基本概念、RabbitMQ的安装、入门程序编写以及RabbitMQ的五种模式解释，并且讲解了如何将RabbitMQ与SpringBoot整合。教程标签包括rabbitmq、pdf、教程和消息队列。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值