RabbitMQ的模式 整合SpringBoot

最新推荐文章于 2024-04-28 09:32:24 发布
最新推荐文章于 2024-04-28 09:32:24 发布
阅读量133 收藏
点赞数
文章标签： rabbitmq spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44188703/article/details/116244230
版权

RabbitMQ

RabbitMQ的模式

简单模式

在这里插入图片描述

代码实现

Product

package com.rabbit.test;

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


public class Product {
    public static void main(String[] args) throws Exception{
        ConnectionFactory factory=new ConnectionFactory();
        System.out.println(factory.getPort());
        factory.setHost("192.168.31.124");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        /**
         * queue 队列名
         * durable 是否持久化队列， rabbitmq服务重启后该队列是否存在
         * exclusive 信道是否独占该队列
         * autoDelete 是否自动删除 如果长时间没有发送消息  则自动删除
         * arg 额外参数  先给null
         */
        channel.queueDeclare("qy129", true, false, false, null);

        String msg = "狗伪凯";
        /**
         * exchange 是交换机名称，没有则为""
         * routingKey 路由key 如果没有交换机绑定就填队列名
         * props 消息的一些额外配置
         * body 消息的内容
         */
        channel.basicPublish("", "qy129", null, msg.getBytes());

    }
}

Comsumers

package com.rabbit;

import com.rabbitmq.client.*;

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

public class Consumers {

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();


        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("内容："+new String(body));
            }
        };

        /**
         * (String queue, 队列的名称
         *  boolean autoAck, 是否自动确认
         *  Consumer callback： 回调方法 当队列中存在信息后 会自动触发回调函数。
         */
        channel.basicConsume("qy129", true, callback);
    }

}

工作者模式

在这里插入图片描述

用处

比如批量处理上. rabbitMQ里面积压了大量的消息。

代码实现

Product

package com.rabbit.work;

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

public class Product {
    public static void main(String[] args) throws Exception{
        ConnectionFactory factory=new ConnectionFactory();
        System.out.println(factory.getPort());
        factory.setHost("192.168.31.124");
        //创建连接对象Connection
        Connection connection=factory.newConnection();
        //创建信道
        Channel channel = connection.createChannel();
        
        channel.queueDeclare("work", true, false, false, null);

        for (int i = 0; i < 10; i++) {
            String msg = "狗伪凯"+i;
            channel.basicPublish("", "work", null, msg.getBytes());
        }

    }
}

Consumer01

package com.rabbit.work;

import com.rabbitmq.client.*;

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

public class Consumer01 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("内容1："+new String(body));
            }
        };

        channel.basicConsume("work", true, callback);
    }
}

Consumer02

package com.rabbit.work;

import com.rabbitmq.client.*;

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

public class Consumer02 {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("内容2："+new String(body));
            }
        };

        channel.basicConsume("work", true, callback);
    }
}

发布订阅模式

在这里插入图片描述

代码实现

Product

package com.rabbit.fanout;

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;

public class Product {
    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        Connection connection = null;
        Channel channel = null;
        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            channel.queueDeclare("fanout01", true, false, false, null);
            channel.queueDeclare("fanout02", true, false, false, null);

            channel.exchangeDeclare("exc", BuiltinExchangeType.FANOUT, true);

            channel.queueBind("fanout01", "exc", "");
            channel.queueBind("fanout02", "exc", "");

            for (int i = 0; i < 20; i++) {
                String s = "狗王伪凯"+i;
                channel.basicPublish("exc","",null,s.getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Consumer01

public class Consumer01 {
    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        Connection connection = null;
        Channel channel = null;

        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            DefaultConsumer callback = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(java.lang.String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("内容1："+new String(body));
                }
            };
            channel.basicConsume("fanout01", true, callback);
        } catch (IOException e) {
            e.printStackTrace();
        }catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

Consumer02

public class Consumer02 {
    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        Connection connection = null;
        Channel channel = null;

        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            DefaultConsumer callback = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("内容2："+new String(body));
                }
            };
            channel.basicConsume("fanout02", true, callback);
        } catch (IOException e) {
            e.printStackTrace();
        }catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

路由模式

在这里插入图片描述

代码实现

Product

package com.rabbit.direct;

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;

public class Product {
    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        Connection connection = null;
        Channel channel = null;
        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            channel.queueDeclare("direct01", true, false, false, null);
            channel.queueDeclare("direct02", true, false, false, null);

            channel.exchangeDeclare("direct", BuiltinExchangeType.DIRECT, true);

            channel.queueBind("direct01", "direct", "error");

            channel.queueBind("direct02", "direct", "error");
            channel.queueBind("direct02", "direct", "info");
            channel.queueBind("direct02", "direct", "debug");


            for (int i = 0; i < 5; i++) {
                String s = "狗王伪凯"+i;
                channel.basicPublish("direct","error",null,s.getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Consumer01

package com.rabbit.direct;

import com.rabbitmq.client.*;

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

public class Consumer01 {

    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        try {
            Connection connection = factory.newConnection();

            Channel channel = connection.createChannel();

            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("direct01:"+new String(body));
                }
            };
            channel.basicConsume("direct01", true, defaultConsumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

Comsumer02

package com.rabbit.direct;

import com.rabbitmq.client.*;

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

public class Consumer02 {

    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        try {
            Connection connection = factory.newConnection();

            Channel channel = connection.createChannel();
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("direct02:"+new String(body));
                }
            };
            channel.basicConsume("direct02", true, defaultConsumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

topic主体模式

在这里插入图片描述

*: 统配一个单词。
#: 统配n个单词

代码实现

Product

package com.rabbit.topics;

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;

public class Product {
    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        Connection connection = null;
        Channel channel = null;
        try {
            connection = factory.newConnection();
            channel = connection.createChannel();
            channel.queueDeclare("topic01", true, false, false, null);
            channel.queueDeclare("topic02", true, false, false, null);

            channel.exchangeDeclare("topic", BuiltinExchangeType.TOPIC, true);

            channel.queueBind("topic01", "topic", "error*");

            channel.queueBind("topic02", "topic", "#.error*");
            channel.queueBind("topic02", "topic", "#.info.#");
            channel.queueBind("topic02", "topic", "debug.#");


            for (int i = 0; i < 5; i++) {
                String s = "狗王伪凯"+i;
                channel.basicPublish("topic","error.ssssssssssssssssssss",null,s.getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }finally {
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Consumer01

package com.rabbit.topic;

import com.rabbitmq.client.*;

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

public class Consumer01 {

    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        try {
            Connection connection = factory.newConnection();

            Channel channel = connection.createChannel();

            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("topic01:"+new String(body));
                }
            };
            channel.basicConsume("topic01", true, defaultConsumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

Consumer02

package com.rabbit.topic;

import com.rabbitmq.client.*;

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

public class Consumer02 {

    public static void main(String[] args) {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.31.124");
        try {
            Connection connection = factory.newConnection();

            Channel channel = connection.createChannel();
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("topic02:"+new String(body));
                }
            };
            channel.basicConsume("topic02", true, defaultConsumer);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

rabbitMQ整合springboot

springboot引入了相关的依赖后，提供一个工具类RabbitTemplate.使用这个工具类可以发送消息。
项目结构
在这里插入图片描述

建立父工程引入相关的依赖

<?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>
    <packaging>pom</packaging>
    <modules>
        <module>product</module>
        <module>consumer</module>
    </modules>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ykq</groupId>
    <artifactId>springboot-rabbit-parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-rabbit-parent</name>
    <description>springboot整合rabbitMQ</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--rabbitMQ的依赖: 启动类加载。读取配置文件：
           springboot自动装配原理: 引用starter启动依赖时，把对应的自动装配类加载进去，该自动装配类可以读取application配置文件中
           内容。 DispatherServlet
        -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.72</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-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>

Producter配置文件

server:
  port: 8080

spring:
  rabbitmq:
    host: 192.168.31.124
  datasource:
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql:///test
      username: root
      password: root

Consumer配置文件

server:
  port: 8081

spring:
  rabbitmq:
    host: 192.168.31.124
  datasource:
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql:///test
      username: root
      password: root

Product

package com.springboot.rabbit.controller;

import com.alibaba.fastjson.JSON;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;

@RestController
public class HelloController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RequestMapping("/hello/{id}/{number}")
    public String hello(@PathVariable("id") Integer id,@PathVariable("number") Integer number) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("id", id);
        map.put("number", number);
        String s = JSON.toJSONString(map);
        //发送消息
        rabbitTemplate.convertAndSend("exc","",s);
        return "购买成功";
    }
}

Consumer01

package com.springboot.rabbit.consumer;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.springboot.rabbit.dao.GoodsMapper;
import com.springboot.rabbit.entity.Goods;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
public class Consumer01 {

    @Autowired
    private GoodsMapper goodsMapper;

    @RabbitListener(queues = {"fanout01"})
    public void consumer(String msg) {
        Map<String,Integer> map = JSON.parseObject(msg, Map.class);

        Goods goods = goodsMapper.selectById(map.get("id"));
        if (goods.getCount() > map.get("number")) {
            goods.setCount(goods.getCount() - map.get("number"));
            goodsMapper.updateById(goods);
            System.out.println(this.getClass().getName()+"出库成功");
        }else{
            System.out.println(this.getClass().getName()+"库存不足");
        }
    }
}

Consumer02

package com.springboot.rabbit.consumer;

import com.alibaba.fastjson.JSON;
import com.springboot.rabbit.dao.GoodsMapper;
import com.springboot.rabbit.entity.Goods;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
public class Consumer02 {

    @Autowired
    private GoodsMapper goodsMapper;

    @RabbitListener(queues = {"fanout02"})
    public void consumer(String msg) {
        Map<String,Integer> map = JSON.parseObject(msg, Map.class);

        Goods goods = goodsMapper.selectById(map.get("id"));
        if (goods.getCount() > map.get("number")) {
            System.out.println("需要支付："+goods.getPrice() * map.get("number"));
        }else{
            System.out.println(this.getClass().getName()+"库存不足");
        }
    }
}
StephenK丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMq整合使用
02-07
RabbitMq的spring boot整合使用，测试成功，简单易懂哈
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
Spring 整合 RabbitMQ
xglfire的博客
09-01 192
需求: 使用Spring 整合 RabbitMQ 步骤 1.创建maven工程 2.添加依赖 3.配置整合 4.编写代码 依赖(生产者和消费者一致): <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId>
Spring Boot与RabbitMQ整合：实现高可用消息队列服务
最新发布
Yaml4的博客
04-28 1187
✌️大厂。
rabbitmq整合spring
liyanlei的专栏
11-29 651
这两天闲着没事玩了下RabbitMQ. MQ全称为Message Queue, （MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同
RabbitMQ 之SpringBoot
const_
07-12 242
文章目录消息推送到接收流程图ExchangeDirect Exchange 消息推送到接收流程图 Exchange 常用的交换机有以下三种，因为消费者是从队列获取信息的，队列是绑定交换机的（一般），所以对应的消息推送/接收模式也会有以下几种： Direct Exchange 直连型交换机 根据消息携带的路由键将消息投递给对应队列。 大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key 。 然后当一个消息携带着路由值为X，这个消息通过生产者发送给交换机时，交换机就会根据这
【消息】RabbitMQ整合
...
06-28 125
自动配置： 1、RabbitAutoConfiguration 2、自动配置了连接工厂CachingConnectionFactory 3、RabbitProperties封装了RabbitMQ的配置 4、RabbitTemplate：给RabbitMQ发送和接收消息 5、AmqpAdmin：系统管理功能组件。AmqpAdmin用来创建和删除queue、exchange、Binding 6、@EnableRabbit+@RabbitListener来监听消息队列里的内容。 示例： pom.xml <?
RabbitMQ整合SpringBoot综合应用
06-19
本篇主要讨论如何将RabbitMQ与SpringBoot进行整合，实现一个综合应用。 首先，RabbitMQ是一个基于AMQP（Advanced Message Queuing Protocol）协议的开源消息代理，它允许应用程序之间发送和接收消息，而无需两者...
Springboot+rabbitmq集成
10-25
文件内包含了rabbit安装的必需文件以及springboot整合rabbitmq的完整代码，代码里包含了原生的rabbitmq使用代码和整合springboot后的使用代码，还有rabbit队列的所有消息队列模式，代码简单易懂，解压打开就可以使用
springboot+整合rabbitmq的全套代码
09-15
reabbitmq的完整学习 >rabbitMq软件上传到liunx服务器 >RabbitMQ入门 ...>Springboot整合RabbitMQ >SpringBoot整合RabbitMQ(交换机与多个队列绑定) >RabbitMQ-集群搭建>负载均衡-HAProxy 完整链接地址: ...
基于SpringBoot整合RabbitMQ发送邮件通知
04-30
整合 SpringBoot 与 RabbitMQ 的过程主要包括以下步骤： 1. **添加依赖**：在 `pom.xml` 文件中引入 SpringBoot 的 `spring-boot-starter-amqp` 依赖，以启用对 RabbitMQ 的支持。 2. **配置 RabbitMQ**：在 `...
RabbitMq整合篇
gu_zhang_w的博客
09-04 206
一 基础知识     rabbitMq 包含如下角色：     producer（生产者） 发消息时一般会指定一个routing key 这个key用于exchange 将消息路由组匹配的queue，同时需要声明exchange     exchange（交换机）根据exchangeType和routing key 将消息发送给匹配的queue     queue（消息队列）与exchan...
RabbitMq整合SSM
LZMLZMLZM268的博客
09-12 2104
rabbitmq，目前比较火的一个MQ消息队列。他有以下特点: RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。 AMQP ：Advanced Message Queue，高级消息队列协议。它是应用层协议的一个开放标准，为面向消息的中间件设计，基于此协议的客户端与消息中间件可传递消息，并不受产品、开发语言等条件的限制。 RabbitMQ 最初起源于金融系统，用于在...
RabbitMq--与SpringBoot整合
BtWangZhi的博客
11-19 2846
1 Spring Boot对RabbitMQ的使用做了自动配置，更加的简化了我们的使用。 添加依赖：&amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt;org.springframework.boot&amp;amp;lt;/groupId&amp;amp;gt; &amp;amp;lt;artifactId&
RabbitMQ 整合 Spring
mrathena
12-02 331
博文目录 文章目录Spring Baseproducerconsumer Spring Base pom.xml <?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://
RabbitMQ的用法整合
weixin_44564365的博客
02-12 380
MQ的作用： 解耦：在项目启动之初是很难预测未来会遇到什么困难的，消息中间件在处理过程中插入了一个隐含的，基于数据的接口层，两边都实现这个接口，这样就允许独立的修改或者扩展两边的处理过程，只要两边遵守相同的接口约束即可。 冗余（存储）：在某些情况下处理数据的过程中会失败，消息中间件允许把数据持久化知道他们完全被处理 扩展性：消息中间件解耦了应用的过程，所以提供消息入队和处理的效率是很容易的，只需...
rabbitMQ整合springboot
二掌柜的博客
03-10 150
springboot 整合rabbitMQ，
项目整合Rabbitmq
望山。
10-26 418
1.拼多商城整合 rabbitmq 当用户下订单时,我们的业务系统直接与数据库通信,把订单保存到数据库中 当系统流量突然激增,大量的订单压力,会拖慢业务系统和数据库系统 我们需要应对流量峰值,让流量曲线变得平缓,如下图 订单存储的解耦 为了进行流量削峰,我们引入 rabbitmq 消息队列,当购物系统产生订单后,可以把订单数据发送到消息队列;而订单消费者应用从消息队列接收订单消息,并把订单保存到数据库 这样,当流量激增时,大量订单会暂存在rabbitmq中,而订单消费者可以从容地从消息队列慢慢接收订单,
spring boot-整合RabbitMq（RabbitMq基础）
西京刀客
11-23 815
文章目录RabbitMq基础Springboot 整合RabbitMq参考 RabbitMq基础 Springboot 整合RabbitMq 参考 SpringBoot集成rabbitmq（一） 参考URL: https://www.cnblogs.com/sword-successful/p/10295561.html
RabbitMQ与SpringBoot整合教程：消息中间件深度解析
本文档将深入探讨RabbitMQ的介绍、由来，以及如何与SpringBoot进行整合。同时，也会涉及AMQP协议的基本概念，包括Broker、Virtualhost和Connection等核心元素。" RabbitMQ是基于AMQP（Advanced Message Queuing ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值