rabbitMQ入门

最新推荐文章于 2022-07-28 17:34:22 发布
最新推荐文章于 2022-07-28 17:34:22 发布
阅读量186 收藏
点赞数 1
分类专栏： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yuwen_forJava/article/details/81901849
版权

序：安装rabbitMQ

参考：https://blog.csdn.net/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入门。纯属个人自己理解，学习路径来源百度，若有错误，欢迎指正，随时修改。

Yuwen_forJava
关注
专栏目录
rabbitMq入门
08-08
【标题】：“rabbitMQ入门” 在IT行业中，消息队列是一种常见的中间件技术，用于解耦应用程序组件，提高系统的可扩展性和可靠性。RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中。本篇文章将带...
RebbitMQ
weixin_45023621的博客
08-24 162
RebbitMQ 简介 消息中间件，将消息以队列的形式进行排序，解决突如其来的浏览导致的系统崩溃，实现模块间的解耦,具有可扩展性、高可用、易用性 组成 生产者：负责发送消息给交换机 交换机：拿到生产者发送的消息发送给消息队列 消息队列：接收到交换机发送的消息，等待消费者接收 消费者：从消息队列中接收消息 应用场景 异步处理： 将不需要马上响应的消息交给消息队列去处理，比如注册用户成功时的发送邮件，发送邮件需要消耗比较长时间并且不需要马上发送，可以交给消息队列派发给消费者去处理 解耦： 将订单系
MQ入门总结（一）消息队列概念和使用场景
热门推荐
Invoker's Tower
11-29 5万+
转载： 转载： 转载： 转载：
RabbitMQ学习记录(一)-MQ的简单介绍
崔二旦
03-30 2533
RabbitMQ使用场景介绍
RabbitMQ - 4种Exchange类型
qq_39508627的博客
04-30 1371
在rabbitmq中，exchange有4个类型：direct，topic，fanout，header。 direct exchange 此类型的exchange路由规则很简单： exchange在和queue进行binding时会设置routingkey channel.QueueBind(queue: "create_pdf_queue", exchan...
几种消息中间件的比较-activemq,robbitmq,rocketmq,kafka
weixin_41150408的博客
06-26 237
1.activemq activemq是Apache出品的,完全支持一个完全支持JMS1.1和J2EE 1.4规范的框架. ⒈ 多种语言和协议编写客户端。语言: Java,C,C++,C#,Ruby,Perl,Python,PHP。应用协议： OpenWire,Stomp REST,WS Notification,XMPP,AMQP ⒉ 完全支持JMS1.1和J2EE 1.4规范 （持久化，X...
RabbitMQ入门视频
04-05
在“RabbitMQ入门视频”中，你将学习到以下关键知识点： 1. **AMQP协议**：首先，了解AMQP协议的基础知识是非常重要的。AMQP定义了一种标准的、面向消息的中间件协议，支持多种语言和平台。它提供了一种可靠的消息...
RabbitMQ入门
01-20
【RabbitMQ 入门详解】 RabbitMQ 是一款开源的消息中间件，它遵循 AMQP（Advanced Message Queuing Protocol）协议，广泛应用于分布式系统中，用于处理异步任务和解耦组件之间的通信。在这个入门教程中，我们将了解...
RabbitMQ入门教程
最新发布
09-12
RabbitMQ入门教程
Rabbitmq入门到精通.doc
08-21
【RabbitMQ 入门到精通】：RabbitMQ 是一款流行的消息中间件，它基于 AMQP（Advanced Message Queuing Protocol）协议实现，用于在分布式系统中高效地传输消息，从而实现异步处理、解耦和流量控制。本教程旨在帮助...
Robot-MQTT-Controller:通过 MQTT 控制机器人或汽车的应用程序
07-16
#Robot MQTT 控制器 这是一个通过 Node-RED 控制机器人或汽车的应用程序。 它内置于 Intel XDK，您可以导入和构建 APK。 用法： 输入 MQTT 服务器的 IP 地址和端口，然后按连接。 例如 192.168.123.4:8080 MQTT 主题应称为“测试”。 输出： 按“连接”：APP已连接！ 输出：前进/后退/左/右/停止中心按钮：切换 255/100
RabbitMQ延迟队列实现定时任务
宋发元
11-25 1764
SpringBoot和SpringCloud框架通用。 使用场景 订单在N分钟内未支付自动取消订单。 指定时间发送运营短信。 用户注册后，N天内未进行下一步操作进行短信操作。 用户发起退款，N时间后通知相关人员处理。 预订会议，会议前N分钟提醒。 利用RabbitMQ实现延时队列 本方法是在消息属性里面设置TTL（Time To Live），这种方式有缺点，消息可能并不会按时被消费，因为RabbitMQ只会检查第一个消息是否过期，如果过期才会丢到死信队列，所以如果第一个消息的延时时间很长，而第二个.
rabbitmq几种交换机的理解以及实践
HUDCHSDI的博客
08-08 1166
交换机 direct 直连 把消息路由到那些binding key与routing key完全匹配的Queue topic Routing Key必须与Binding Key相匹配的时候才将消息传送给Queue 和direct 都需要绑定route-key topic的#和*,# 表示和多个关键字匹配，* 和一个关键字匹配 header 匹配不依赖于route-key和banding...
RabbitMQ介绍
qq_37876078的博客
06-24 408
一、rabbitmq是什么 MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法，举例：微信用户A给微信用户B发送一条消息需要通过腾讯的服务器转发，那么这个腾讯服务器就是充当了MQ的角色。 二、rebbitmq使用场景 高并发下操作某一张数据表（订单表），数据库的压力很大，这时候就需要将所有的订单信息形式存放到Mq里，并直接返回用户端“下单成功”。然后消费者那边的mysq只能操作完一条数据才能执行下一条数据，从而减轻压力（为什么会减轻压力，这因为消费者那边的业务处理逻辑
Rocket MQ发送消息的三种方式初析
FeelTouch Labs
08-13 4161
前言 MQ 发送消息有三种实现方式：可靠同步发送、可靠异步发送、单向(Oneway)发送。基于版本4.2.0+。注意：顺序消息只支持可靠同步发送。 可靠同步发送 原理：同步发送是指消息发送方发出数据后，会在收到接收方发回响应之后才发下一个数据包的通讯方式。 场景：此种方式应用场景非常广泛，例如重要通知邮件、报名短信通知、营销短信系统等。 可靠异步发送 原理：异步发送是指发送方发出数...
RabbitMQ管理端代码（开箱即用）
RuiKe的博客
02-26 569
骨架图： 依次介绍： 一、MQ配置：RabbitConfig
RocketMQ 添加监控和系统告警通知
我的程序人生(亦山札记)
03-02 1万+
前言 最近由于RocketMQ在使用过程中，发现在某些时候消息堆积，并且还是长时间堆积不消费，这种情况下没能及时发现，导致客户投诉，所以就有给RocketMQ增加监控，当出现特定异常时，能够及时告警，及时处理。 首先提出我们的监控诉求，出现如下情况时，希望能够及时接收到系统告警通知： RocketMQ 服务宕机 RocketMQ 消费者下线 RocketMQ 消息出现长时间或者大量堆积 本文将...
消息队列4：rabbitmq的配置
火焰
04-18 9671
环境： centos8.2 RabbitMQ 3.8.8 Erlang 23.0 rabbitmq的安装参照： 《linux下安装rabbitmq》 本文参照：https://www.rabbitmq.com/configure.html rabbitmq的安装位置为： /usr/local/rabbitmq 一、rabbitmq的日志文件 rabbitmq的默认日志文件位置为： /usr/local/rabbitmq/var/log/rabbitmq/rabbit@*t.log，如下图所示：
rabbitmq详解
m0_67393342的博客
07-28 2774
RabbitMQ是一个实现了AMQP（AdvancedMessageQueuingProtocol）高级消息队列协议的消息队列服务，用Erlang语言。是面向消息的中间件。你可以把它想像成一个邮局你把信件放入邮箱，邮递员就会把信件投递到你的收件人处。在这个比喻中，RabbitMQ是一个邮箱、邮局、邮递员。RabbitMQ和邮局的主要区别是，它处理的不是纸，而是接收、存储和发送二进制的数据——消息。主要流程。...
rabbitmq入门
07-27
\[3\] RabbitMQ入门指南文章 希望这些信息对你有帮助！ #### 引用[.reference_title] - *1* *2* *3* [超详细的RabbitMQ入门](https://blog.csdn.net/Rok728/article/details/123106242)[target="_blank" data-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值