RabbitMQ

已于 2024-08-19 22:15:26 修改
阅读量574 收藏 6
点赞数 12
文章标签： java 开发语言 mybatis spring 服务器
于 2024-08-19 22:15:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luosuss/article/details/141320598
版权

目录

同步调用：一次只能干一件事

 异步通信：一次可以同时做很多事

MQ(MessageQueue)

docker安装RabbitMq

第一步：拉取镜像

第二步：启动rabbitmq

方式一：直接启动

方式二：使用docker-compose创建并运行容器

 RabbitMQ消息模型

一.基本消息队列（BasicQueue）

二. 工作消息队列（WorkQueue）

三.发布订阅（Publish、Subscribe）

1.Fanout Exchange：广播

 2.Direct Exchange：路由

3.topic Exchange：主题 

SpringAMQP

第一步：先创建一个SpringBoot项目，然后在当前项目创建出两个新的模块，分别命名为publisher,consumer。

第二步：修改主项目的打包方式为pom,java版本为1.8,springboot版本为2.3.10.RELEASE，并导入amqp的依赖

第三步：让两个模块继承这个主项目的依赖，使用标签

 第四步：在两个子模块下的applicaton.yml文件下配置连接RabbitMQ的信息

使用SpringAMQP处理基本消息队列

第一步：在publisher模块中书写发送消息队列的类

第二步： 在consumer模块书写接收消息队列的类

 使用SpringAMQP处理工作消息队列

publisher模块中发送消息的类

consumer模块中接收消息的类

在consumer模块中的application.yml文件中添加prefetch

使用SpringAMQP处理发布订阅之广播

publisher模块中发送消息的类

consumer模块中接收消息的类

我们也可以使用配置类来创建交换机和队列，并绑定

使用SpringAMQP处理发布订阅之路由

 consumer模块中接收消息的类

publisher模块中发送消息的类

使用SpringAMQP处理发布订阅之主题

  consumer模块中接收消息的类

publisher模块中发送消息的类

配置JSON转换器

在主项目的pom.xml文件中导入依赖

 在两个子模块中书写配置类，将MessageConverter交给IoC容器

同步调用：一次只能干一件事

同步调用的优点：
时效性高，可以立即得到结果

同步调用的问题：

  • 耦合度高
  • 性能下降
  • 有额外的资源消耗
  • 有级联失败的问题

 异步通信：一次可以同时做很多事

优点：

  • 耦合度低
  • 性能提升
  • 故障隔离
  • 流量削峰

缺点：

  • 依赖于Broker(事件代理者)的可靠性，安全性，性能提升能力
  • 架构变得更加复杂

MQ(MessageQueue)

MQ就是消息队列，就是事件驱动架构中的Broker

常用的MQ:RabbitMQ,ActiveMQ,RocketMQ,Kafka

docker安装RabbitMq

第一步：拉取镜像

docker pull rabbitmq:3.8-management

 

第二步：启动rabbitmq

方式一：直接启动
docker run \
 -e RABBITMQ_DEFAULT_USER=hhh \
 -e RABBITMQ_DEFAULT_PASS=1234 \
 -v mq-plugins:/plugins \
 --name mq \
 --hostname mq \
 -p 15672:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3.8-management
# 设置环境变量  用户名是 hhh
 -e RABBITMQ_DEFAULT_USER=hhh \
 # 设置环境变量  密码是 1234
 -e RABBITMQ_DEFAULT_PASS=1234 \
 # 挂载数据卷，如果没有该数据卷会自己创建
 -v mq-plugins:/plugins \
 # mq的名字
 --name mq \
 # 主机名 这里不配置也可以
 --hostname mq \
 # web可视化终端监控端口；mq的ui界面管理平台端口
 -p 15672:15672 \
 # 程序与mq交互的访问端口；发消息和收消息的端口
 -p 5672:5672 \
 # 后端运行
 -d \
 # 镜像名称
 rabbitmq:3.8-management
[root@localhost docker-compose]# docker ps -a
CONTAINER ID   IMAGE                     COMMAND                   CREATED          STATUS          PORTS                                                                                                                                                 NAMES
ea34ab693409   rabbitmq:3.8-management   "docker-entrypoint.s…"   45 seconds ago   Up 44 seconds   4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, :::5672->5672/tcp, 15671/tcp, 15691-15692/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp, :::15672->15672/tcp   mq

 启动成功

方式二：使用docker-compose创建并运行容器

我们先把之前创建的容器删除

docker rm -f mq

yml文件内容

version: "3.2"

services:
  mysql:
    image: mysql:5.7.25  #使用的镜像
    container_name: mysql_container #容器名字
    environment:
      MYSQL_ROOT_PASSWORD: 1234
    volumes:    #数据卷，绑定容器内的文件和宿主机文件
      - "/tmp/mysql/data:/var/lib/mysql"
      - "/tmp/mysql/conf/my.cnf:/etc/mysql/conf.d/my.cnf"
    ports:
      - "3306:3306"
  radditmq:
    image: rabbitmq:3.8-management
    container_name: mq
    environment:
      RABBITMQ_DEFAULT_USER: hhh
      RABBITMQ_DEFAULT_PASS: 1234
    volumes:
      - "mq-plugins:/plugins"
    ports:
      - "15672:15672"
      - "5672:5672"
volumes:
  mq-plugins: {} #要创建的数据卷

在yml文件所在目录使用命令

docker-compose up -d

[root@localhost docker-compose]# ll
总用量 4
-rw-r--r--. 1 root root 653 8月  19 12:06 docker-compose.yml
drwxr-xr-x. 2 root root  39 8月  18 21:35 myweb-service
[root@localhost docker-compose]# docker up -d

运行成功

[root@localhost docker-compose]# docker ps -a
CONTAINER ID   IMAGE                     COMMAND                   CREATED          STATUS          PORTS                                                                                                                                                 NAMES
1faf568f83de   mysql:5.7.25              "docker-entrypoint.s…"   45 seconds ago   Up 44 seconds   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp                                                                                                  mysql_container
ea34ab693409   rabbitmq:3.8-management   "docker-entrypoint.s…"   45 seconds ago   Up 44 seconds   4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, :::5672->5672/tcp, 15671/tcp, 15691-15692/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp, :::15672->15672/tcp   mq
 

 RabbitMQ消息模型

一.基本消息队列（BasicQueue）

生产者将消息发送到队列，消费者从队列中获取消息，队列是存储消息的缓冲区。

二. 工作消息队列（WorkQueue）

工作消息队列是基本消息队列的增强版，具有多个消费者消费队列的消息。假设消息队列中积压了多个消息，那么此时可以使用多个消费者来消费队列中的消息。效率要比基本消息队列模型高。

三.发布订阅（Publish、Subscribe）

1.Fanout Exchange：广播

将消息交给所有绑定到交换机的队列,生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。交换机把消息发送给绑定过的所有队列.队列的消费者都能拿到消息。实现一条消息被多个消费者消费.

 2.Direct Exchange：路由

在广播模式中，生产者发布消息，所有消费者都可以获取所有消息.

使用路由模式时，生产者向Exchange发送消息，发送消息时，会指定一个routing key

Exchange（交换机）接收生产者的消息后，就会把把消息递交给 与routing key完全匹配的队列

3.topic Exchange：主题 

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

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

3.通配符规则：

#：匹配一个或多个词

*：匹配恰好1个词

SpringAMQP

第一步：先创建一个SpringBoot项目，然后在当前项目创建出两个新的模块，分别命名为publisher,consumer。

第二步：修改主项目的打包方式为pom,java版本为1.8,springboot版本为2.3.10.RELEASE，并导入amqp的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.10.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>


    <groupId>com.hhh</groupId>
    <artifactId>spring_day10_mq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring_day10_mq</name>
    <description>spring_day10_mq</description>
    <packaging>pom</packaging>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--AMQP依赖，包含RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

第三步：让两个模块继承这个主项目的依赖，使用<parent>标签

注意：模块的<artifactId>publisher</artifactId>不能少

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.hhh</groupId>
        <artifactId>spring_day10_mq</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <artifactId>publisher</artifactId>
</project>
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.hhh</groupId>
        <artifactId>spring_day10_mq</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>consumer</artifactId>
</project>

 第四步：在两个子模块下的applicaton.yml文件下配置连接RabbitMQ的信息

logging:
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS   #日志文件的格式
spring:
  rabbitmq:
    host: 192.168.230.100  # 主机名
    port: 5672 # 发送消息和接收消息的端口号
    virtual-host: / # 虚拟主机
    username: hhh # 用户名
    password: 1234 # 密码

使用SpringAMQP处理基本消息队列

第一步：在publisher模块中书写发送消息队列的类

@RunWith(SpringRunner.class)//TODO:是一个测试启动器，可以加载SpringBoot测试注解,让测试方法在Spring容器环境下执行
@SpringBootTest
public class BaseMessage {
    @Autowired
    RabbitTemplate rabbitTemplate;
    @Test
    public void simpleMessage(){
        //1.定义队列名字
        String queue="simple.queue";
        //2.定义消息内容
        String msg="你好，这是hhh发送的消息";
        //3.发送消息
        rabbitTemplate.convertAndSend(queue,msg);
    }
}

点击发送之后，可以发现消息队列的总数变成1

第二步： 在consumer模块书写接收消息队列的类

//TODO:把这个交给Spring容器管理
@Component
public class BaseMessageListener {
    @RabbitListener(queues = "simple.queue")//只接受simple.queue队列的消息
    public void getBaseMassage(String msg){//定义参数来接收消息
        System.out.println(msg);
    }
}

启动SpringBoot引导类

接收成功，消息队列总数变成0

 使用SpringAMQP处理工作消息队列

思路就是使用多个监听类，来接收同一个消息队列的消息

publisher模块中发送消息的类

@Test
    public void workMessage(){
        //1.定义队列名字
        String queue="simple.queue";
        //2.定义消息
        String msg="这是工作消息";
        //3.发送消息
        for(int i=0;i<50;i++){
            rabbitTemplate.convertAndSend(queue,msg+i);
        }

    }

consumer模块中接收消息的类

public class BaseMessageListener {
    @RabbitListener(queues = "simple.queue")
    public void getWorkMessage1(String msg) throws InterruptedException {
        System.out.println("这是消费者1:"+msg);
        Thread.sleep(20);//休息20毫秒
    }
    @RabbitListener(queues = "simple.queue")
    public void getWorkMessage2(String msg) throws InterruptedException {
        System.out.println("这是消费者2:"+msg);
        Thread.sleep(50);//休息50毫秒
    }
}

 启动后发现这两个消费者类是平分了这些消息

是因为消息队列会把消息分配平均交给负责监听此消息队列的类，这样做的弊端就是，有的消费者类很快就能执行完，而有可能会很满，导致效率底下，所以我们可以进行修改

在consumer模块中的application.yml文件中添加prefetch

spring:
  rabbitmq:
    host: 192.168.230.100   #主机名
    port: 5672        #用于发送信息和接收信息的端口号
    virtual-host: /    #虚拟主机
    username: hhh    #用户名
    password: 1234 #密码
    listener:
      simple:
        prefetch: 1
prefetch:
预取:每次将队列中的消息发送给消费者一个消息，等消费者处理完后再继续给一个消息
这样一来，处理消息快的消费者就会处理更多的消息
不修改之前，是把消息队列里的消息进行平分

可以发现处理快的消费者就可以处理更多的消息

使用SpringAMQP处理发布订阅之广播

在广播模式下，消息发送流程是这样的：

  • 1） 可以有多个队列
  • 2） 每个队列都要绑定到Exchange（交换机）
  • 3） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定
  • 4） 交换机把消息发送给绑定过的所有队列
  • 5） 订阅队列的消费者都能拿到消息

因此我们要

  • 创建一个交换机 itcast.fanout，类型是Fanout
  • 创建两个队列fanout.queue1和fanout.queue2，绑定到交换机itcast.fanout

publisher模块中发送消息的类

@RunWith(SpringRunner.class)
@SpringBootTest
public class FanoutMessage {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void test(){
        //定义交换机名字
        String exchangeName="hhh.fanout";
        //定义消息
        String msg="你好呀，fanout";
        //发送消息
//第二个参数是RoutingKey,因为这里使用的广播类型（让于其绑定的消息队列都收到消息），所以设置为空
        rabbitTemplate.convertAndSend(exchangeName,"",msg);
    }
}

consumer模块中接收消息的类

@Component
public class FanoutListener {
    //这里创建了一个消息队列fanout.queue1，和一个fanout类型的交换机（如果本来存在就不会重新创建），并且绑定
    //绑定的同时也指定了这个类监听消息队列fanout.queue1
    @RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue1"),
        exchange = @Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)
    ))
    public void getFanoutMessage1(String msg){
        System.out.println("这是消费者1:"+msg);
    }
    @RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue2"),
            exchange =@Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)
    ))
    public void getFanoutMessage2(String msg){
        System.out.println("这是消费者2:"+msg);
    }

}

结果：两个消费者（都与交换机进行绑定）都可以接收到消息

我们也可以使用配置类来创建交换机和队列，并绑定

@Configuration
public class FanoutConfig {
    //创建fanoutExchange交换机，并交给IoC容器，bean id 为getFanoutExchange
    @Bean
    public FanoutExchange getFanoutExchange(){
        return new FanoutExchange("hhh.fanout");
    }
    //创建消息队列1，并交给IoC容器，bean id 为getQueue1
    @Bean
    public Queue getQueue1(){
        return new Queue("fanout.queue1");
    }
    //创建消息队列2，并交给IoC容器，bean id 为getQueue2
    @Bean
    public Queue getQueue2(){
        return new Queue("fanout.queue2");
    }
    //TODO:将消息队列绑定到交换机上
    //TODO:注意：由于SpringBoot会帮我们创建交换器类型，和Queue类型的bean,而我们又自己创建了相同类型的bean
    //我们这里要指定bean的名字，不然Spring自动装配就会报错，不知道要装配哪个bean
    //TODO:因此我们要让Spring根据bean的id来进行注入
    @Bean
    public Binding bindingQueue1ToExchange(FanoutExchange getFanoutExchange,Queue getQueue1){
       return BindingBuilder.bind(getQueue1).to(getFanoutExchange);
    }
    @Bean
    public Binding bindingQueue2ToExchange(FanoutExchange getFanoutExchange,Queue getQueue2){
        return BindingBuilder.bind(getQueue2).to(getFanoutExchange);
    }
}
@Component
public class FanoutListener {
    //这里创建了一个消息队列fanout.queue1，和一个fanout类型的交换机（如果本来存在就不会重新创建），并且绑定
    //绑定的同时也指定了这个类监听消息队列fanout.queue1
   /* @RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue1"),
        exchange = @Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)
    ))*/
    @RabbitListener(queues = "fanout.queue1")
    public void getFanoutMessage1(String msg){
        System.out.println("这是消费者1:"+msg);
    }
    /*@RabbitListener(bindings = @QueueBinding(value = @Queue("fanout.queue2"),
            exchange =@Exchange(name="hhh.fanout",type = ExchangeTypes.FANOUT)
    ))*/
    @RabbitListener(queues = "fanout.queue2")
    public void getFanoutMessage2(String msg){
        System.out.println("这是消费者2:"+msg);
    }

}

使用SpringAMQP处理发布订阅之路由

在Direct模型下：

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
  • 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。
  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

 consumer模块中接收消息的类

@Configuration
public class DirectMessageListener {
    @RabbitListener(bindings = @QueueBinding(value = @Queue("direct.queue1"),
        exchange = @Exchange(name="hhh.direct",type= ExchangeTypes.DIRECT),
            key = {"yellow","red"} //指定这个消息队列绑定的RouterKey
    ))
    public void getDirectMessage1(String msg){
        System.out.println("这是消费者1:"+msg);
    }
    @RabbitListener(bindings = @QueueBinding(value = @Queue("direct.queue"),
        exchange = @Exchange(name="hhh.direct",type=ExchangeTypes.DIRECT),
            key={"yellow","blue"} //指定这个消息队列绑定的RouterKey
    ))
    public void getDirectMessage2(String msg){
        System.out.println("这是消费者2:"+msg);
    }
}

publisher模块中发送消息的类

@RunWith(SpringRunner.class)
@SpringBootTest
public class DirectMessage {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void test(){
        //定义交换机名字
        String exchangeName="hhh.direct";
        //定义消息
        String msg="你好，direct";
        //发送消息，指定发送给RouterKey为yellow的消息队列
        rabbitTemplate.convertAndSend(exchangeName,"yellow",msg);

    }
}

结果：两个消费者都收到了消息队列，因为他们都有yellow这个RouterKey 

使用SpringAMQP处理发布订阅之主题

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

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

通配符规则：

#：匹配一个或多个词

*：匹配不多不少恰好1个词

举例：

item.#：能够匹配item.spu.insert 或者 item.spu

item.*：只能匹配item.spu

  consumer模块中接收消息的类

@RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "hhh.topic", type = ExchangeTypes.TOPIC),
            key = "china.#" //key = "china.#" 表示路由key只要以china开始都会接收
    ))
    public void listenTopicQueue1(String msg) {
        System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "hhh.topic", type = ExchangeTypes.TOPIC),
            key = "#.news" //表示路由key只要以news结尾都会接收
    ))
    public void listenTopicQueue2(String msg) {
        System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
    }

publisher模块中发送消息的类

 @Test
    public void testSendTopicExchange() {
        // 交换机名称
        String exchangeName = "itcast.topic";
        // 消息
        String message = "你好，topic";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "china.news", message);
    }

配置JSON转换器

默认情况下Spring采用的序列化方式是JDK序列化，JDK序列化存在下列问题：

  • 数据体积过大
  • 有安全漏洞
  • 可读性差

我们希望消息体的体积更小、可读性更高，因此可以使用JSON方式来做序列化和反序列化。

在主项目的pom.xml文件中导入依赖

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

 在两个子模块中书写配置类，将MessageConverter交给IoC容器

/*
    消息转换器
 */

@Configuration
public class MessageConverterConfig {
    @Bean//将json转换器对象放到IoC容器
    public MessageConverter jsonMessageConverter(){
        return new Jackson2JsonMessageConverter();
    }
}

落落落sss
关注
  • 12
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
RabbitMQ安装
qq_57442639的博客
07-02 9511
rabbitmq
RabbitMQ入门
SICAUliuy的博客
04-20 2653
RabbitMQ简介 安装步骤 在centos7环境上， 因为是最小化安装，需要先yum install gcc 依赖 wget 对应的安装包 erlang、socat、rabbitmq-server 通过rpm 安装 顺序是 erlang、socat、rabbitmq-server 常用命令 # 启动 systemctl start rabbitmq-server # 添加web管理插件 rabbitmq-plugins enable rabbitmq_management # 重启 syst
Rabbitmq
asddasddeedd的博客
11-19 6169
消息队列 消息服务器 消息中间件 Borker。
linux安装rabbitmq
zjg
12-31 3156
rabbit是使用erlang语言开发的，所以我们需要先进行erlang的安装，版本也要对的上，本次以安装为最新版的安装包形式进行安装。回到顶部。
rabbitmq server
帅的没拼音
12-07 2730
服务启动与停止 service rabbitmq-server start #启动服务 service rabbitmq-server stop #停止服务 service rabbitmq-server status #查看状态 开通STOMP通道 rabbitmq-plugins enable rabbitmq_web_stomp rabbitmq-plugins enable rabbitmq_web_stomp_examples #重启 service rabbitmq-se...
启动rabbitmq
s1095622320的博客
03-10 1733
当rabbitmq-service install之后默认服务是enable的，如果这时设置服务为disable的话，rabbitmq-service start就会报错。当rabbitmq-service start正常启动服务之后，使用disable是没有效果的。rabbitmq-plugins disable rabbitmq_management 关闭。rabbitmq-plugins enable rabbitmq_management 启动。3、Rabbitmq 管理插件启动，可视化界面。
windows环境下安装RabbitMQ（超详细）
热门推荐
luckySnow的博客
01-23 11万+
总结有rabbitmq安装报错解决办法（超详细）消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题实现高性能，高可用，可伸缩和最终一致性[架构] 使用较多的消息队列有 ActiveMQ（安全），RabbitMQ，ZeroMQ，Kafka（大数据），MetaMQ，RocketMQ以下介绍消息队列在实际应用中常用的使用场景：异步处理，应用解耦，流量削锋和消息通讯四个场景1.2什么是RabbitMQRabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。
【Windows安装RabbitMQ详细教程】
tirster的博客
12-14 9万+
Windows安装RabbitMQ详细教程前言一、RabbitMQ是什么？二、使用步骤1.引入库2.读入数据总结 前言 下面我将分享下RabbitMQ最新版本在Windows上的详细安装教程。 笔者在这里使用的系统环境如下： windows系统：Windows 11 专业版 21H2 erlang： 一、RabbitMQ是什么？ RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。 ​ AMQP ：Advanced Message Queue，高级消息队列协议。它是应用层协议的
RabbitMQ Server3.13.0
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
rabbitmqadmin
07-08
RabbitMQ命令行手动创建队列rabbitmqadmin用法 手动创建队列方法：登录http://ip:15672/cli下载 将下载的rabbitmqadmin放到/usr/sbin目录下，并赋予权限：chmod 755 rabbitmqadmin 查看命令帮助信息： python ...
rabbitmq开发规范
07-04
**RabbitMQ开发规范详解** 在使用RabbitMQ进行分布式消息传输时，遵循一定的开发规范至关重要，这不仅可以提高系统的可维护性，也有助于保证数据的一致性和稳定性。本篇文章将详细阐述RabbitMQ的命名规范、消息传输...
rabbitmq3.10.4
06-07
RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中的消息传递。它基于AMQP（Advanced Message Queuing Protocol）协议，为多种编程语言提供API，使得开发人员能够轻松地实现消息的发送和接收。在...
JAVA进阶补充
2301_80150315的博客
08-15 955
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
Java基础之原反补码
u012135697的博客
08-14 460
整数类型数据在计算机底层进行存储或运算，以补码方式进行！ 正整数的原反补码，一模一样！
【Spring框架】
最新发布
m0_71941456的博客
08-18 641
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1099
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

落落落sss

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值