rabbitMQ入门

Yuwen_forJava Yuwen_forJava 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 200+累计阅读 250平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄9年
关注
原创 最新推荐文章于 2026-03-23 16:44:14 发布 250 阅读 AI 写同款· GEO 优化 ›
【RabbitMQ】RabbitMQ快速入门 通俗易懂 初学者入门 【推荐】RabbitMQ快速入门 1小时上手学会RabbitMQ 阅读详情

序：安装rabbitMQ

参考：https://blog.youkuaiyun.com/Yuwen_forJava/article/details/81661929

1. 什么是rabbitMQ

MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断写入消息，而另一端则可以读取队列中的消息。

RabbitMQ是MQ的一种。

 

2. rabbitMQ基础

2.1 rabbitMQ流程

 2.2 producr生产者

消息生产者，就是投递消息的程序。向rabbitmq发送消息+指定的routing key

2.3 Exchange

exchange翻译是交换的意思。exchange属于rabbitmq的模块，它和queue绑定在一起，通过一个binding key ，binding key 允许相同。exchange接收来自product的消息，根据routing key、binding key以及exchange的种类进行消息的分发，把消息发往相应的queue。

exchange常见的种类有3种：fanout、direct、topic

fanout：把所有发送到该Exchange的消息投递到所有与它绑定的队列中。广播

direct：把消息投递到那些binding key与routing key完全匹配的队列中。精准匹配

topic：将消息路由到binding key与routing key模式匹配的队列中。模糊匹配

2.4 queue

rabbitmq内部模块，保存消息。

2.5 custom

消息消费者，处理消息。

 

3. rabbitMQ使用场景

应用解耦

场景：双11是购物狂节,用户下单后,订单系统需要通知库存系统,传统的做法就是订单系统调用库存系统的接口.

这种做法有一个缺点:当库存系统出现故障时,订单就会失败。(这样马云将少赚好多好多钱^ ^)

订单系统和库存系统高耦合.引入消息队列

订单系统:用户下单后,订单系统完成持久化处理,将消息写入消息队列,返回用户订单下单成功。

库存系统:订阅下单的消息,获取下单消息,进行库操作。

就算库存系统出现故障,消息队列也能保证消息的可靠投递,不会导致消息丢失(马云这下高兴了).

流量削峰

流量削峰一般在秒杀活动中应用广泛

场景:秒杀活动，一般会因为流量过大，导致应用挂掉,为了解决这个问题，一般在应用前端加入消息队列。

作用:

1.可以控制活动人数，超过此一定阀值的订单直接丢弃(我为什么秒杀一次都没有成功过呢^^)

2.可以缓解短时间的高流量压垮应用(应用程序按自己的最大处理能力获取订单)

 

4.案例

和spring进行了整合

创建两个maven web项目，分别用eclipse和idea运行，互相调用。

以下是idea运用的代码

项目目录：

项目依赖

 <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
        <!-- spring版本号 -->
        <spring.version>4.3.5.RELEASE</spring.version>
        <!-- mybatis版本号 -->
        <mybatis.version>3.4.1</mybatis.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <!-- RabbitMQ -->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
            <version>1.4.5.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!-- java ee -->
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>7.0</version>
        </dependency>

        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <!-- 实现slf4j接口并整合 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.2</version>
        </dependency>

        <!-- JSON -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.8.7</version>
        </dependency>


        <!-- 数据库 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.41</version>
            <scope>runtime</scope>
        </dependency>

        <!-- 数据库连接池 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>

        <!-- MyBatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>

        <!-- mybatis/spring整合包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>

        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- <dependency> <groupId>javax.servlet</groupId> <artifactId>jsp-api</artifactId>
            <version>2.0</version> <scope>provided</scope> </dependency> -->


        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>

        <!--redis -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.6.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.7.3</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.13</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.46</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.0</version>
        </dependency>

        <!-- Spring 整合Shiro需要的依赖 -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-web</artifactId>
            <version>1.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>1.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>

    </dependencies>

创建配置product.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit-1.5.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置connection-factory，指定连接rabbit server参数-->
    <rabbit:connection-factory id="connectionFactory" username="root" password="root"
                               host="localhost"
                               port="5672"
                               virtual-host="/"/> <!-- virtual-host="/"是默认的虚拟机路径-->
    <rabbit:admin connection-factory="connectionFactory"/>

    <rabbit:queue id="queue_idea" durable="true" auto-delete="false"
                  exclusive="false" name="queue_idea">
    </rabbit:queue>
    
    <rabbit:direct-exchange name="exchange_insurance" durable="true" auto-delete="false" id="exchange_insurance">
        <rabbit:bindings>
            <rabbit:binding queue="queue_idea" key="testKeyIdea"/>
        </rabbit:bindings>
    </rabbit:direct-exchange>

    <!-- 客户端投递消息到exchange -->
    <rabbit:template id="amqpTemplate" exchange="exchange_insurance" connection-factory="connectionFactory"/>
</beans>

创建配置custom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit-1.5.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置connection-factory，指定连接rabbit server参数-->
    <rabbit:connection-factory id="connectionFactory2" username="root" password="root"
                               host="localhost"
                               port="5672"
                               virtual-host="/"/> <!-- virtual-host="/"是默认的虚拟机路径-->
    <rabbit:admin connection-factory="connectionFactory2"/>

    <!-- queue 队列声明 -->
    <!-- queue 队列声明  name 队里的额name 是关联生产表和消费表的为唯一线索  -->
    <rabbit:queue id="queue_eclipse" name="queue_eclipse"></rabbit:queue>

    <!-- 定义消费者监听器 -->
    <!-- 创建一个bean实例，bean实例中声明处理请求的类 -->
    <bean id="consumerLitener2" class="cn.yu.service.RabbitMQConsumer"></bean>

    <rabbit:listener-container  connection-factory="connectionFactory2" acknowledge="auto" concurrency="8">
        <!-- queues属性从那个队列中接收消息，ref属性是当存在消息是使用哪个类去处理 -->
        <rabbit:listener  queues="queue_eclipse" ref="consumerLitener2"/>
    </rabbit:listener-container>
</beans>

 

创建applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.2.xsd

	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
	">

    <!-- 扫描service包下所有使用注解的类型 -->
    <context:component-scan base-package="cn.yu"/>

    <import resource="classpath*:rabbitmq/product.xml"/>
    <import resource="classpath*:rabbitmq/custom.xml"/>

</beans>

spring-mvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

    <!-- 扫描web相关的bean -->
    <context:component-scan base-package="cn.yu"/>

    <!-- 开启SpringMVC注解模式 -->
    <mvc:annotation-driven/>

    <!-- 静态资源默认servlet配置 -->
    <mvc:default-servlet-handler/>

    <!-- 配置jsp 显示ViewResolver -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
  <display-name>ChatRobot</display-name>
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-*.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
  </servlet>
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

index.jsp,两个index是一样的

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
<h2>Hello RabbitMq!</h2>
<a href="/sendMsg"><button>点击这个，发送消息到eclipse</button></a>
</body>
</html>

RabbitmqController
  @Resource
    private RabbitMQProducer rabbitMQProducer;

    @RequestMapping("sendMsg")
    public String sendMsg(){
        String msg = new String("开始发消息1号sfda");
        System.out.println("开始发消息");
        rabbitMQProducer.sendMessage(msg);
        System.out.println("发出了消息");
        return "index";
    }
RabbitMQConsumer继承MessageListener，实现onMessage方法
@Service
public class RabbitMQConsumer implements MessageListener {
    public void onMessage(Message message) {
        System.out.println("消息！");
        System.out.println(message);
        System.out.println("消息getMessageProperties！");
        System.out.println(message.getMessageProperties());
        System.out.println("消息getBody");
        try {
            String ss = new String(message.getBody(), "UTF-8");
            System.out.println(ss);
        } catch (UnsupportedEncodingException e) {
        }
//        System.out.println(1/0);
    }
}

RabbitMQProducer 

@Service
public class RabbitMQProducer {

    @Resource
    private AmqpTemplate amqpTemplate;

    public void sendMessage(Object message) {
        amqpTemplate.convertAndSend("testKeyIdea",message);//testKey为配置文件中queue对应的key,指明发送给哪个queue。
    }
}

eclipse和idea一样，只需要修改produc.xml和custom.xml中的一点配置即可，以下：

product.xml

​

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit-1.5.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置connection-factory，指定连接rabbit server参数-->
    <rabbit:connection-factory id="connectionFactory" username="root" password="root"
                               host="localhost"
                               port="5672"
                               virtual-host="/"/> <!-- virtual-host="/"是默认的虚拟机路径-->
    <rabbit:admin connection-factory="connectionFactory"/>

    <rabbit:queue id="queue_eclipse" durable="true" auto-delete="false"
                  exclusive="false" name="queue_eclipse"><!--正常队列当中指向死信-->
        <!--<rabbit:queue-arguments>-->
            <!--<entry key="x-message-ttl">&lt;!&ndash;设置超时&ndash;&gt;-->
                <!--<value type="java.lang.Long">30000</value>-->
            <!--</entry>-->
            <!--<entry key="x-dead-letter-exchange">&lt;!&ndash;指定交换机&ndash;&gt;-->
                <!--<value type="java.lang.String">alter</value>-->
            <!--</entry>-->
        <!--</rabbit:queue-arguments>-->
    </rabbit:queue>
    <!--<rabbit:queue id="alter_queue" durable="true" auto-delete="false" exclusive="false" name="alter_queue"/>&lt;!&ndash;死信队列&ndash;&gt;-->
    <!--<rabbit:direct-exchange name="alter" durable="true" auto-delete="false" id="alter">&lt;!&ndash;死信交换机&ndash;&gt;-->
        <!--<rabbit:bindings>-->
            <!--<rabbit:binding queue="alter_queue" key="testKey"/>-->
        <!--</rabbit:bindings>-->
    <!--</rabbit:direct-exchange>-->
    <rabbit:direct-exchange name="exchange_insurance" durable="true" auto-delete="false" id="exchange_insurance"><!--正常交换机-->
        <rabbit:bindings>
            <rabbit:binding queue="queue_eclipse" key="testKeyeEclipse"/>
        </rabbit:bindings>
    </rabbit:direct-exchange>

    <!-- 客户端投递消息到exchange -->
    <rabbit:template id="amqpTemplate" exchange="exchange_insurance" connection-factory="connectionFactory"/>
</beans>


​

coustom.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit-1.5.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置connection-factory，指定连接rabbit server参数-->
    <rabbit:connection-factory id="connectionFactory2" username="root" password="root"
                               host="localhost"
                               port="5672"
                               virtual-host="/"/> <!-- virtual-host="/"是默认的虚拟机路径-->
    <rabbit:admin connection-factory="connectionFactory2"/>

    <!-- queue 队列声明 -->
    <!-- queue 队列声明  name 队里的额name 是关联生产表和消费表的为唯一线索  -->
    <rabbit:queue id="queue_idea" name="queue_idea">
    </rabbit:queue>

    <!-- 定义消费者监听器 -->
    <!-- 创建一个bean实例，bean实例中声明处理请求的类 -->
    <bean id="consumerLitener2" class="cn.yu.service.RabbitMQConsumer"></bean>

    <rabbit:listener-container
            connection-factory="connectionFactory2" acknowledge="auto" concurrency="8">
        <!-- queues属性从那个队列中接收消息，ref属性是当存在消息是使用哪个类去处理 -->
        <rabbit:listener queues="queue_idea" ref="consumerLitener2"/>
    </rabbit:listener-container>
</beans>

 

 

 

 

以上，为rabbitmq入门。纯属个人自己理解，学习路径来源百度，若有错误，欢迎指正，随时修改。

收录于
rabbitmq

当前文章被收录于：

rabbitmq
2 篇文章 0 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
RabbitMQ 从入门到精通 消息中间件基于队列模型实现异步/同步传输数据作用：可以实现支撑高并发、异步解耦、流量削峰、降低耦合度。 阅读详情

相关推荐

RabbitMQ入门案例

案例中生产者叫做 Task，一个消费者就是一个工作队列，启动两个工作队列消费消息，这个两个工作队列会以轮询的方式消费消息。假设生产者生产 AA BB CC DD这四条消息，理论上工作线程C1和工作线程C2轮询接收到消息，期望测试结果如下。轮询消费消息指的是轮流消费消息，即每个工作队列都会获取一个消息进行消费，并且获取的次数按照顺序依次往下轮流。创建一个类作为消费者，消费 RabbitMQ 队列的消息，消息消费是通过Channel来完成的。在运行第二个工作线程，此时已经开了两个工作线程，如下。

不怕万人阻挡，只怕自己投降 1777

RebbitMQ

RebbitMQ 简介 消息中间件，将消息以队列的形式进行排序，解决突如其来的浏览导致的系统崩溃，实现模块间的解耦,具有可扩展性、高可用、易用性 组成 生产者：负责发送消息给交换机 交换机：拿到生产者发送的消息发送给消息队列 消息队列：接收到交换机发送的消息，等待消费者接收 消费者：从消息队列中接收消息 应用场景 异步处理： 将不需要马上响应的消息交给消息队列去处理，比如注册用户成功时的发送邮件，发送邮件需要消耗比较长时间并且不需要马上发送，可以交给消息队列派发给消费者去处理 解耦： 将订单系

weixin_45023621的博客 260

Robot-MQTT-Controller:通过 MQTT 控制机器人或汽车的应用程序

#Robot MQTT 控制器 这是一个通过 Node-RED 控制机器人或汽车的应用程序。 它内置于 Intel XDK，您可以导入和构建 APK。 用法： 输入 MQTT 服务器的 IP 地址和端口，然后按连接。 例如 192.168.123.4:8080 MQTT 主题应称为“测试”。 输出： 按“连接”：APP已连接！ 输出：前进/后退/左/右/停止中心按钮：切换 255/100

MQ入门总结（一）消息队列概念和使用场景

转载： 转载： 转载： 转载：

Invoker's Tower 5万+

HBM PHY 架构解析：从主控模块到DWORD设计的深度探索

本文深入解析了HBM PHY的完整架构，从作为系统大脑的PUB主控模块出发，详细阐述了其CSR控制、初始化与训练引擎的核心功能。进而剖析了负责命令传输的AWORDX2模块与作为数据高速公路的DWORD模块的设计奥秘，包括其双向数据流、精密时钟对齐与延迟线校准机制。最后，探讨了顶层MASTER PHY的整合作用及从DFI到DRAM的完整数据通路，为理解这一高性能内存接口的关键物理层设计提供了全面视角。

weixin_29306011的博客 296

对西安交大轴承数据集XJTU-SY_Bearing_Datasets进行读取和处理：

故障诊断，对西安交大轴承数据集XJTU-SY_Bearing_Datasets进行读取和处理

qq_44757503的博客 6067

初识RabbitMq

可以把mq想象成一个仓库，将消息进行存储，然后再转发，谁需要就进行订阅数据，接收并且转发消息，mq在不同情况下表现是不同的，比如异步解耦，有一些操作比较耗费时间，比如用户注册的时候，通过mq邮箱通知用户注册成功，使用mq进行请求存储，进行请求挨个处理。发布数据的时候会给每个数据都带上序号标签，比如1，2，3，当broker收到消息的时候，就会返回一个ack，比如ack带的值是3，那就说明了3以前的数据都已经收到了，也就是收到了1，2，3。创建连接，创建channel，声明队列，消费信息，释放资源。

syx050403的博客 1293

robot framework循环读取excel表操作

robot framework循环读取excel表操作 1、安装excellibrary，注意python3.7版本，需安装：robotframework-excel，robotframework-excellibrary-xwfintech 注意：网上有很多excel处理的，都是基于python2.7的，还有一些对python3以上都是修改包的方式，其实都不需要，在pip官网上有python3以上的excellibrary，名称是robotframework-excellib 2.0.0，但是该包关键字不

余墨的博客 1321

RabbitMQ学习记录(一)-MQ的简单介绍

RabbitMQ使用场景介绍

崔二旦 2668

【tips】在PyCharm中安装opencv图文版详细教程

pip如下图所示，左边的蓝色图标就是终端。点开终端后，键入命令，按下回车后就开始下载了。如果你更喜欢图形化操作，可以在 PyCharm 中直接安装：。点击右上角的 +按钮（添加包）。搜索或，点击。

zhousanguhe的博客 6744

《大数据最全面试题-Offer直通车》目录

做好这些不用担心试用期不通过：程序员入职新公司如何快速上手项目本人遇到大数据面试题和参考答案（超过1万字精华版）大数据面试英文自我介绍参考（万字长文）大数据运维应用场景面试题汇总及参考答案（持续更新）万字数据仓库面试题及参考答案数据仓库数据质量监控和处理方法最佳实践数据仓库建模方法万字详解Doris的3种数据模型详解和数据仓库每一层的模型选用大数据面试临阵磨枪不知看什么？看这份心理就有底了-大数据常用技术栈常见面试100道题最全Hive面试题2024年（2万字详解）Elasticsearch 面试题及参考答

大模型大数据攻城狮的专栏 2650

RabbitMQ - 4种Exchange类型

在rabbitmq中，exchange有4个类型：direct，topic，fanout，header。 direct exchange 此类型的exchange路由规则很简单： exchange在和queue进行binding时会设置routingkey channel.QueueBind(queue: "create_pdf_queue", exchan...

qq_39508627的博客 1466

[QMT量化交易小白入门]-二十四、年化收益47%的全球核心资产轮动策略(含代码解析)

m_days = 25 #动量参考天数period=200m_days被设置为25，表示动量参考的天数为25天；period被设置为200，用于指定获取市场数据的周期长度。

木头大左的博客 2971

RabbitMQ的快速入门

RabbitMQ是一套开源（MPL）的消息队列服务软件，是由 LShift 提供的一个 Advanced Message Queuing Protocol (AMQP) 的开源实现，由以高性能、健壮以及可伸缩性出名的Erlang写成。

博客 1156

mabl：AI原生测试自动化平台的基础使用

mabl是一个基于人工智能和机器学习的云原生测试自动化平台。它通过使用先进的技术，如机器学习，自动创建和执行测试，自动分析测试结果，并根据需求的变化自动适配和维护测试。这样的自动化过程极大地提高了软件测试的效率和准确性。mabl的口号是 “You write code, mabl tests”，意味着开发者只需关注编写代码，而测试工作则可以交给mabl来完成。mabl的平台支持多种测试类型，包括 Web、App、Api、可访问性和性能测试，使得团队能够更快速、更有信心地发布软件。

blues_C的博客 3661

基于龙虾Claw的会议纪要自动提取与重点内容总结办公场景实践

本文介绍如何使用龙虾Claw构建会议纪要自动提取与重点内容总结系统，实现会议内容的智能处理。

一键难忘的博客 255

RabbitMQ入门

RabbitMQ 是一个开源的消息中间件（Message Broker），实现了消息队列的功能，允许不同的应用程序或服务之间通过消息进行异步通信。RabbitMQ 采用 Erlang 语言实现了AMQP（Advanced Message Queuing Protocol，高级消息队列协议）标准，提供了可靠的消息传递、队列管理、消息路由等功能

2301_76161469的博客 2138

C# WinForm 基于DirectShow.dll编写的程序，可边预览边保存视频，音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择（默认选中第一个）2.可录制wmv和avi两种格式的视频并且都带有音频，avi可以录制的分辨率和帧数进行选择，wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照，也可边录制视频边拍照4.添加了视频和音频的压缩功能（酌情使用）这次二次开发发现C#对DirectShow的相关信息太少，这次做完也不敢藏私共享出来，还望大家指正

超详细的RabbitMQ入门

转载：超详细的RabbitMQ入门，看这篇就够了！-阿里云开发者社区 思维导图 一、什么是消息队列 消息指的是两个应用间传递的数据。数据的类型有很多种形式，可能只包含文本字符串，也可能包含嵌入对象。 “消息队列(Message Queue)”是在消息的传输过程中保存消息的容器。在消息队列中，通常有生产者和消费者两个角色。生产者只负责发送数据到消息队列，谁从消息队列中取出数据处理，他不管。消费者只负责从消息队列中取出数据处理，他不管这是谁发送的数据。 二、为什么使用消息队列 主要有三个作用

Rok728的博客 2万+

汉书HE8，好用的汇编代码编写工具

汉书HE8，好用的汇编代码编写工具早期编写汇编代码所用功能强大

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明，包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

RabbitMQ快速入门

RabbitMQ快速入门指南 本文介绍了RabbitMQ的基本概念和常见使用模式。首先讲解了通过Docker安装RabbitMQ的方法，并解释了核心概念如channel、exchange、queue和virtual host。然后详细介绍了三种消息队列模型：简单队列模型（单一生产者和消费者）、工作队列模型（多个消费者共同处理）和发布订阅模型（通过exchange实现消息广播）。文章提供了SpringBoot整合RabbitMQ的具体代码示例，包括生产者发送消息和消费者接收消息的实现方式，以及Fanout E

qq_45528306的博客 1274

【RabbitMQ】入门(超详细)

MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。今天将实现rabbitMQ的快速入门。

Jorgen_s的博客 1128

超详细的RabbitMQ入门，看这篇就够了

什么的消息队列？为什么使用消息队列？如何使用RabbitMQ？看这篇就够了

yehongzhi1994的博客 6205

RabbitMQ入门小结

​ RabbitMQ概述 RabbitMQ是基于Erlang语言开发的开源消息通信中间件，官网地址：Messaging that just works — RabbitMQ ​

一切总会归于平淡 2068

RabbitMQ最新入门教程

1.什么是消息队列 2.为什么使用消息队列 3.消息队列协议 4.安装Erlang 5.安装RabbitMQ 6.RabbitMQ核心模块 7.RabbitMQ六大模式 7.1 简单模式 7.2 工作模式 7.3 发布订阅模式 7.4 路由模式 7.5 主题模式 7.6 RPC模式 8.RabbitMQ四种交换机 8.1 直连交换机 8.2 主题交换机 8.3 扇形交换机 8.4 首部交换机 9.RabbitMQ Management使用 9.1 Queues操作 9.2 Exchanges操作

自己在学习过程中的总结 3506

RabbitMQ3：Java客户端快速入门

AMQP：Advanced Message Queuing Protocol（高级消息队列协议）。解读：首先AMQP是一种协议，类似于http这种，规定了应用程序之间传递消息的标准。该协议与语言、平台无关，因此可实现跨语言、跨平台。Spring AMQP：是基于AMQP协议，定义的一套API规范。提供了模板来发送和接收消息。Spring AMQP官方网址：此时是生产者直接将消息放入队列，都没经过交换机这一环节。可见此入门案例，是helloworld级别的。t=O83A。

casually的博客 1501
上一篇： shiro入门教程——SSM整合shiro编写一个案例
下一篇： The valid characters are defined in RFC 7230 and RFC 3986
点赞 1
评论 0
书签 书签 0
Yuwen_forJava
Yuwen_forJava
博客等级 码龄9年 28粉丝 90原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值