Rabbitmq 缓存数据库

最新推荐文章于 2023-08-08 20:12:04 发布
最新推荐文章于 2023-08-08 20:12:04 发布
阅读量2.9k 收藏 1
点赞数
分类专栏： SpringCloud 文章标签： redis java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55740233/article/details/121415357
版权

Rabbitmq概念

消息队列、消息服务器、消息中间件Borker
常见消息服务器：Rabbitmq Activemq Rocketmq(阿里的) Kafka Tubemq(腾讯)

搭建Rabbitmq服务器

VMware

  • 16.x
  • NAT网段 192.168.64.0
  • 编辑–虚拟网络编辑器–选择vmnet8–左下角修改成192.168.64.0
    在这里插入图片描述

虚拟机

centos-8-2105/centos-7-1908

  • 已经做了基本配置
    yun安装源、扩展源使用阿里服务器
    安装了python、pip、ansible
    添加了两个脚本文件，方便配置ip地址（ip-static固定ip/ip-dhcp自动获取ip）
  • 1.解压centos-8-2105
  • 2.双击centos-8-2105.vmx加载镜像
  • 3.启动，按提示选择已复制虚拟机
  • 4.登录用户名密码都是 root

ip设置测试

  1. ./ip-dhcp 自动获取ip
  2. 如果网卡有问题 执行以下命令
# centos 8 开启 VMware 托管 
nmcli n on systemctl restart NetworkManager
# centos 7 禁用 NetworkManager 系统服务 
systemctl stop NetworkManager systemctl disable NetworkManager
#如果网络还有问题，可以充值vmware虚拟网络
编辑--虚拟网络篇编辑器--还原默认设置
还原默认设置会删除所有虚拟网络，重新创建，重新初始化

在这里插入图片描述

默认分配的ip
在这里插入图片描述
静态设置ip
在这里插入图片描述

准备docker环境

1.关闭centos-8-2105

2.克隆centos-8-2105：docker-base

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

3.mobaxterm连接docker-base

ip：192.168.64.3
注意：先打开虚拟机

4.上传文件到/root

/DevOPs/Docker/docker-install
在这里插入图片描述

5. 离线安装docker（参考CSND笔记）

# 进入 docker-install 文件夹
cd docker-install
# 为 docker-install 添加执行权限
chmod +x install.sh

# 安装
./install.sh -f docker-20.10.6.tgz

在这里插入图片描述

6.关机

一般执行shutdown
在这里插入图片描述

Docker运行Rabbitmq

1.克隆docker-base ：rabbitmq

2.设置ip

./ip-static
ip:192.168.64.140
ifconfig

3.上传rabbitmq镜像到/root

/docker/rabbit-image.gz

4.导入镜像

docker load -i rabbit-image.gz

5.启动rabbitmq

关闭防火墙

systemctl stop firewalld
systemctl disable firewalld
 
# 重启 docker 系统服务
systemctl restart docker

配置管理员用户名和密码

mkdir /etc/rabbitmq
vim /etc/rabbitmq/rabbitmq.conf

# 添加两行配置：
default_user = admin
default_pass = admin

启动Rabbitmq

docker run -d --name rabbit \
-p 5672:5672 \
-p 15672:15672 \
-v /etc/rabbitmq/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf \
-e RABBITMQ_CONFIG_FILE=/etc/rabbitmq/rabbitmq.conf \
--restart=always \
rabbitmq:management

在这里插入图片描述
访问网址http://192.168.64.140:15672
在这里插入图片描述
用户名/密码：admin
在这里插入图片描述

Rabbitmq使用场景

服务解耦

MQ Message Queue
数据吞吐量很大
数据排队

异步调用

feign是同步调用，效率低
mq异步调用

Rabbitmq六种收发消息方式

准备工作

新建工程

在这里插入图片描述

新建module

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

添加依赖

 <dependencies>
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.4.3</version>
        </dependency>
    </dependencies>

简单模式

只有一个消费者
在这里插入图片描述
生产者代码

package m1;
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 Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);//收发消息5672
        f.setUsername("admin");
        f.setPassword("admin");
        Connection con = f.newConnection();//创建连接
        Channel channel = con.createChannel();//通信的通道  与服务器通信使用channel
        //2.在服务器上创建 helloworld队列
        //队列如果已经存在，不会重复创建
        channel.queueDeclare("helloworld",false,false,false,null);
        //3.向helloworld发送消息
        channel.basicPublish("", "helloworld",null,"Hello World".getBytes());
    }
}

channel.queueDeclare()参数说明

  • 参数：
    * 1.队列名
    * 2.是否是持久队列
    * 3.是否是排他队列，可共享（独占队列）
    * 4.是否能被服务器自动删除（没有消费者的时候服务器是否自动删除）
    * 5.队列的其他参数属性（键值对）
    channel.basicPublish参数说明
  • 1.交换机，空串是默认交换机
  • 3.消息的其他参数属性（键值对）
    在这里插入图片描述
    在这里插入图片描述
    消费者代码
package m1;

import com.rabbitmq.client.*;

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

/*简单模式--消费者*/
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);//收发消息5672
        f.setUsername("admin");
        f.setPassword("admin");
        Connection con = f.newConnection();//创建连接
        Channel channel = con.createChannel();//通信的通道  与服务器通信使用channel
        //2.在服务器上创建 helloworld队列
        //队列如果已经存在，不会重复创建
        channel.queueDeclare("helloworld",false,false,false,null);
        //创建回调对象
        //处理消息的回调函数
        DeliverCallback deliverCallback1=(consumerTag,message)->{
            byte[] a=message.getBody();
            String s=new String(a);
            System.out.println("收到"+s);
        };
        DeliverCallback deliverCallback=new DeliverCallback() {
            @Override
            public void handle(String consumerTag, Delivery message) throws IOException {
                byte[] a=message.getBody();
                String s=new String(a);
                System.out.println("收到"+s);
            }
        };
        //取消消息的回调对象
        CancelCallback cancelCallback=new CancelCallback() {
            @Override
            public void handle(String consumerTag) throws IOException {

            }
        };
        //从helloworld接收消息，把消息传递到回调对象处理
//        channel.basicConsume("helloworld",true,处理消息的回调对象，取消消息处理回调对象);        channel.basicConsume("helloworld",true,deliverCallback1,cancelCallback);
    }
}

channel.basicConsume参数说明
第二个参数：确认方式 ACK --Acknowledgment
* -true 自动确认
* -false 手动确认（手动发送回执） 保证正确处理消息
在这里插入图片描述
在这里插入图片描述

工作模式

多个消费者
在这里插入图片描述
生产者代码

package m1;

import com.rabbitmq.client.*;

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

/*简单模式--消费者*/
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);//收发消息5672
        f.setUsername("admin");
        f.setPassword("admin");
        Connection con = f.newConnection();//创建连接
        Channel channel = con.createChannel();//通信的通道  与服务器通信使用channel
        //2.在服务器上创建 helloworld队列
        //队列如果已经存在，不会重复创建
        channel.queueDeclare("helloworld",false,false,false,null);
        //创建回调对象
        //处理消息的回调函数
        DeliverCallback deliverCallback1=(consumerTag,message)->{
            byte[] a=message.getBody();
            String s=new String(a);
            System.out.println("收到"+s);
        };
        DeliverCallback deliverCallback=new DeliverCallback() {
            @Override
            public void handle(String consumerTag, Delivery message) throws IOException {
                byte[] a=message.getBody();
                String s=new String(a);
                System.out.println("收到"+s);
            }
        };
        //取消消息的回调对象
        CancelCallback cancelCallback=new CancelCallback() {
            @Override
            public void handle(String consumerTag) throws IOException {

            }
        };
        //从helloworld接收消息，把消息传递到回调对象处理
//        channel.basicConsume("helloworld",true,处理消息的回调对象，取消消息处理回调对象);
        /*
        * 第二个参数：确认方式 ACK --Acknowledgment
        * -true 自动确认
        * -false 手动确认（手动发送回执） 保证正确处理消息
        * */
channel.basicConsume("helloworld",true,deliverCallback1,cancelCallback);
    }
}

在这里插入图片描述
在这里插入图片描述
消费者代码
业务：模拟耗时消息

package m2;

import com.rabbitmq.client.*;

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

/*工作模式--消费者*/
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);//收发消息5672
        f.setUsername("admin");
        f.setPassword("admin");
        Connection con = f.newConnection();//创建连接
        Channel channel = con.createChannel();//通信的通道  与服务器通信使用channel
        //2.在服务器上创建 helloworld队列
        //队列如果已经存在，不会重复创建
        channel.queueDeclare("helloworld",false,false,false,null);
        //回调对象
        DeliverCallback deliverCallback=(consumerTag,message)->{
            String s=new String(message.getBody());
            System.out.println(s);
            //遍历所有字符，遇到.暂停1s
            for (int i = 0; i < s.length(); i++) {
                if(s.charAt(i)=='.'){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("消息处理完成");
        };
        CancelCallback cancelCallback=(consumerTag)->{};
        //接收信息
        channel.basicConsume("helloworld",true,deliverCallback,cancelCallback);
    }
}

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

如何解决合理分发？？

  • 手动确认+qos
    在这里插入图片描述
    修改Consumer代码
package m2;

import com.rabbitmq.client.*;

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

/*工作模式--消费者*/
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);//收发消息5672
        f.setUsername("admin");
        f.setPassword("admin");
        Connection con = f.newConnection();//创建连接
        Channel channel = con.createChannel();//通信的通道  与服务器通信使用channel
        //2.在服务器上创建 helloworld队列
        //队列如果已经存在，不会重复创建
        channel.queueDeclare("helloworld",false,false,false,null);
        //回调对象
        DeliverCallback deliverCallback=(consumerTag,message)->{
            String s=new String(message.getBody());
            System.out.println(s);
            //遍历所有字符，遇到.暂停1s
            for (int i = 0; i < s.length(); i++) {
                if(s.charAt(i)=='.'){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
//            channel.basicAck(回执,是否同时确认收到过的所有消息);
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            System.out.println("消息处理完成");
        };
        CancelCallback cancelCallback=(consumerTag)->{};
        //每次只收一条，处理完之前不收下一条
        channel.basicQos(1);
        //接收信息
        //第二个参数为false手动确认
        channel.basicConsume("helloworld",false,deliverCallback,cancelCallback);
    }
}

重启消费者模块测试
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

如何实现持久化？？

  1. 队列持久化

修改生产者代码

package m2;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;

/*工作模式--生产者*/
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);//收发消息5672
        f.setUsername("admin");
        f.setPassword("admin");
        Connection con = f.newConnection();//创建连接
        Channel channel = con.createChannel();//通信的通道  与服务器通信使用channel
        //2.在服务器上创建 helloworld队列
        //队列如果已经存在，不会重复创建
        channel.queueDeclare("task_queue",true,false,false,null);
        //循环输入消息发送
        while (true){
            System.out.println("输入消息：");
            String s=new Scanner(System.in).nextLine();
            channel.basicPublish("","task_queue",null,s.getBytes());
        }
    }
}

修改消费者代码

package m2;

import com.rabbitmq.client.*;

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

/*工作模式--消费者*/
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);//收发消息5672
        f.setUsername("admin");
        f.setPassword("admin");
        Connection con = f.newConnection();//创建连接
        Channel channel = con.createChannel();//通信的通道  与服务器通信使用channel
        //2.在服务器上创建 helloworld队列
        //队列如果已经存在，不会重复创建
        channel.queueDeclare("task_queue",true,false,false,null);
        //回调对象
        DeliverCallback deliverCallback=(consumerTag,message)->{
            String s=new String(message.getBody());
            System.out.println(s);
            //遍历所有字符，遇到.暂停1s
            for (int i = 0; i < s.length(); i++) {
                if(s.charAt(i)=='.'){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
//            channel.basicAck(回执,是否同时确认收到过的所有消息);
            channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            System.out.println("消息处理完成");
        };
        CancelCallback cancelCallback=(consumerTag)->{};
        //每次只收一条，处理完之前不收下一条
        channel.basicQos(1);
        //接收信息
        //第二个参数为false手动确认
        channel.basicConsume("task_queue",false,deliverCallback,cancelCallback);
    }
}
  1. 消息持久化
    ```生产者代码修改`
    在这里插入图片描述
package m2;

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

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

/*工作模式--生产者*/
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPort(5672);//收发消息5672
        f.setUsername("admin");
        f.setPassword("admin");
        Connection con = f.newConnection();//创建连接
        Channel channel = con.createChannel();//通信的通道  与服务器通信使用channel
        //2.在服务器上创建 helloworld队列
        //队列如果已经存在，不会重复创建
        channel.queueDeclare("task_queue",true,false,false,null);
        //循环输入消息发送
        while (true){
            System.out.println("输入消息：");
            String s=new Scanner(System.in).nextLine();
            channel.basicPublish("","task_queue", MessageProperties.PERSISTENT_BASIC,s.getBytes());
        }
    }
}

重启rabbit测试

交换机模式

交换机
direct ：直连（默认）
fanout：扇出、扇形
topic：主题
在这里插入图片描述

Producer

package m3;

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

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

/*交换机模式*/
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPassword("admin");
        f.setUsername("admin");
        f.setPort(5672);
        Channel channel = f.newConnection().createChannel();
        //创建 Fanout类型的交换机：logs(模拟程序中产生的日志消息)
        channel.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
        //向logs交换机发送消息
        while(true){
            System.out.println("输入消息：");
            String s=new Scanner(System.in).nextLine();
            //第二个参数对于fanout交换机无效
            channel.basicPublish("logs","",null,s.getBytes() );
        }
    }
}

Consumer

package m3;

import com.rabbitmq.client.*;

import javax.xml.stream.FactoryConfigurationError;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.TimeoutException;

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPassword("admin");
        f.setUsername("admin");
        f.setPort(5672);
        Channel channel = f.newConnection().createChannel();
        //1.创建随机队列
        String queue= UUID.randomUUID().toString();
        channel.queueDeclare(queue, false,true,true,null);
        //2.创建交换机
        channel.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
        //3.队列绑定到交换机  第三个参数对fanout 交换机无效
        channel.queueBind(queue,"logs", "");
        //4.正常从随机队列接收处理消息
        DeliverCallback deliverCallback=(comsumerTag,message)->{
            String s = new String(message.getBody());
            System.out.println("收到："+s);
        };
        CancelCallback cancelCallback=consumerTag -> {};
        channel.basicConsume(queue,true,deliverCallback,cancelCallback);//true为自动确认
    }

}
  • 交换机发出的消息，无人接收直接丢弃

为什么消费者也需要创建交换机？？

路由模式

关键词匹配路由消息，和谁匹配就发送到对应的队列

Rabbitmq如何创建路由空间？
在这里插入图片描述
在这里插入图片描述
Producer代码

package m4;

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


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

/*路由模式*/
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPassword("admin");
        f.setUsername("admin");
        f.setPort(5672);
        f.setVirtualHost("/");//默认空间 可以在服务器创建自己的空间
        Channel channel = f.newConnection().createChannel();
        //创建Direct交换机 direct:logs
        channel.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);
        //发送消息 在消息上携带路由键
        while (true){
            System.out.println("输入消息:");
           String s= new Scanner(System.in).nextLine();
            System.out.println("输入路由键:");
            String k= new Scanner(System.in).nextLine();
            //第二个参数：路由键关键词
            //如果使用默认交换机，路由键就是队列名
            channel.basicPublish("direct_logs",k,null,s.getBytes());
        }
    }
}

Consumer代码

package m4;

import com.rabbitmq.client.*;

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

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
            //连接
            ConnectionFactory f = new ConnectionFactory();
            f.setHost("192.168.64.140");
            f.setPassword("admin");
            f.setUsername("admin");
            f.setPort(5672);
            f.setVirtualHost("/");//默认空间 可以在服务器创建自己的空间
            Channel channel = f.newConnection().createChannel();
            //创建随机队列 创建交换机 绑定 设置绑定键
            //让服务器自动命名 自动提供队列参数:随即名,false,true,true
        String queue = channel.queueDeclare().getQueue();
        channel.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);
        System.out.println("输入绑定键，用空格隔开:");//"aa bb x"
        String s = new Scanner(System.in).nextLine();
        String[] a = s.split("\\s+");//   \s是空白字符  +代表1-多个
        for (String k : a) {
            channel.queueBind(queue,"direct_logs",k);
        }
        //从随机队列接收处理消息
        DeliverCallback deliverCallback=(consumerTag,message)->{
            String msg = new String(message.getBody());
            System.out.println(msg);
        };
        CancelCallback cancelCallback=consumerTag -> {};
        channel.basicConsume(queue,true,deliverCallback,cancelCallback);

    }
}

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

主题模式

Producer代码

package m5;

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

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

/*路由模式*/
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.140");
        f.setPassword("admin");
        f.setUsername("admin");
        f.setPort(5672);
        f.setVirtualHost("/");//默认空间 可以在服务器创建自己的空间
        Channel channel = f.newConnection().createChannel();
        //创建Direct交换机 direct:logs
        channel.exchangeDeclare("topic_logs", BuiltinExchangeType.TOPIC);
        //发送消息 在消息上携带路由键
        while (true){
            System.out.println("输入消息:");
           String s= new Scanner(System.in).nextLine();
            System.out.println("输入路由键:");
            String k= new Scanner(System.in).nextLine();
            //第二个参数：路由键关键词
            //如果使用默认交换机，路由键就是队列名
            channel.basicPublish("topic_logs",k,null,s.getBytes());
        }

    }
}

Consumer代码

package m5;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeoutException;
/*主题模式*/
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
            //连接
            ConnectionFactory f = new ConnectionFactory();
            f.setHost("192.168.64.140");
            f.setPassword("admin");
            f.setUsername("admin");
            f.setPort(5672);
            f.setVirtualHost("/");//默认空间 可以在服务器创建自己的空间
            Channel channel = f.newConnection().createChannel();
            //创建随机队列 创建交换机 绑定 设置绑定键
            //让服务器自动命名 自动提供队列参数:随即名,false,true,true
        String queue = channel.queueDeclare().getQueue();
        channel.exchangeDeclare("topic_logs", BuiltinExchangeType.TOPIC);
        System.out.println("输入绑定键，用空格隔开:");//"aa bb x"
        String s = new Scanner(System.in).nextLine();
        String[] a = s.split("\\s+");//   \s是空白字符  +代表1-多个
        for (String k : a) {
            channel.queueBind(queue,"topic_logs",k);
        }
        //从随机队列接收处理消息
        DeliverCallback deliverCallback=(consumerTag,message)->{
            String msg = new String(message.getBody());
            System.out.println(msg);
        };
        CancelCallback cancelCallback=consumerTag -> {};
        channel.basicConsume(queue,true,deliverCallback,cancelCallback);
    }
}

实现效果
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

BUS组件实现配置刷新

2.3.4.9

利威尔兵短
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ【RabbitMQ概念（优势、劣势、应用场景 、AMQP、工作原理）】(一)-全面详解（学习总结---从入门到深化）
04-12 642
RabbitMQ【RabbitMQ概念（优势、劣势、应用场景 、AMQP、工作原理）】(一)-全面详解（学习总结---从入门到深化）
手动清除RabbitMQ队列的消息缓存
qq_43160049的博客
02-18 8116
手动清除rabbitmq的队列消息缓存
RabbitMQ实现消息缓冲
qiulig
07-04 2197
RabbitMQ实现消息缓冲 RabbitMQ主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。RabbitMQ使用的是AMQP（高级消息队列）协议，它是一种二进制协议。默认启动端口5672 rabbitMQ的message model实际上消息不直接发送到queue中，中间有一个exchange是做消息分发，生产者producer甚至不知道消息发送到哪个队列中去。因...
RabbitMQ入门系列01----RabbitMQ简介
qq_46147786的博客
08-31 1788
MQ：是在消息的传输过程中保存消息的容器。用于分布式系统之间进行通信 AMQP:是一个网络协议，是应用层协议的一个开放标准，为面向消息的中间件设计
rabbitmq 批量监听拿取数据
qq_38093703的博客
12-08 3563
项目需求为： 现有一共有三四十个队列，每个队列都必须要做到顺序监听，每个队列里面接收到的数据需要保存到数据库中，队列发送频率大约为30毫秒，一秒30多条，这就需要频繁访问数据库同时访问一个表，导致数据表不能同时存入数据（涉及到id不能重复） 所以现在改成把需要存储的数据发送到rabbitmq上，然后一次性监听几千条数据，做批量存储。 这是rabbitmq的 ...
MQ消息存储选择
Leon_Jinhai_Sun的博客
10-31 846
从主流的几种MQ消息队列采用的存储方式来看，主要会有三种 1. 分布式KV存储，比如ActiveMQ中采用的levelDB、Redis， 这种存储方式对于消息读写能力要求不高的情况下可以使用 2. 文件系统存储，常见的比如kafka、RocketMQ、RabbitMQ都是采用消息刷盘到所部署的机器上的文件系统来做持久化，这种方案适合对于有高吞吐量要求的消息中间件，因为消息刷盘是一种高效率，高可靠、高性能的持久化方式，除非磁盘出现故障，否则一般是不会出现无法持久化的问题 3. 关系型数据库，比如Acti
springboot 与redis、cache、rabbitmq、数据库读写分离
07-20
springboot学习资源，对接mybatis数据库，实现数据库读写分离，实现本地cache缓存，实现rabbitmq消息中心，实现redis分布式缓存； 详情见readme文件 a、数据库，已提供user.sql,需要导入个人库，并在application....
Redis缓存与数据库一致性解决方案1
08-03
【Redis缓存与数据库一致性解决方案】 在高并发的业务环境中，数据库常常成为性能瓶颈。因此，引入Redis作为缓存来分担数据库的压力是常见的优化手段。然而，这种架构会带来缓存与数据库之间的一致性问题。主要问题...
miaosha 模拟双11、618活动商品秒杀，瞬间大流量并发、引入消息中间件rabbitmq、缓存Nosql、做静态缓存
最新发布
01-12
本项目"miaosha"旨在模拟这类场景，通过引入消息中间件RabbitMQ，配合NoSQL缓存策略，实现高效稳定的静态缓存机制。 首先，让我们深入理解一下关键组件和技术： 1. **RabbitMQ**：RabbitMQ是一款开源的消息队列...
RabbitMQ启动启动有向图1
08-03
file_handle_cache 节点是 RabbitMQ 启动流程图的第六个节点，表示 RabbitMQ 的文件句柄缓存。这一步骤是 RabbitMQ 启动的必要条件，确保 RabbitMQ 的文件句柄缓存正确。 worker_pool 节点 worker_pool 节点是 ...
springboot+redis整合rabbitmq
04-21
Spring Boot以其便捷的配置和快速的应用开发而受到广泛欢迎，Redis是高性能的内存数据结构存储，常用于缓存和消息中间件，而RabbitMQ则是一个稳定且功能丰富的消息队列系统，能够实现异步处理和解耦应用程序。...
超详细的RabbitMQ入门，看这篇就够了
weixin_64353239的博客
08-08 779
消息指的是两个应用间传递的数据。数据的类型有很多种形式，可能只包含文本字符串，也可能包含嵌入对象。“消息队列(Message Queue)”是在消息的传输过程中保存消息的容器。在消息队列中，通常有生产者和消费者两个角色。生产者只负责发送数据到消息队列，谁从消息队列中取出数据处理，他不管。消费者只负责从消息队列中取出数据处理，他不管这是谁发送的数据。这篇文章就先写到这里了。什么是消息队列？为什么使用消息队列？RabbitMQ的特点、组成部分、工作流程。
RabbitMQ 消息持久化
19：30的博客
01-06 1889
rabbitmq 消息持久化
基于Docker部署RabbitMQ集群
m0_67391521的博客
04-12 250
一、使用集群的原因 使用集群的原因 最开始我们介绍了如何安装及运行 RabbitMQ 服务, 不过这些是单机版的, 无法满足目前真实应用的要求. 如果 RabbitMQ 服务器遇到内存崩溃、机器掉电或者主板故障等情况, 该怎么办 单台 RabbitMQ 服务器可以满足每秒 1000 条消息的吞吐量, 那么如果应用需要 RabbitMQ 服务满足每秒 10 万条消息的吞吐量呢 购买昂贵的服务器来增强单机 RabbitMQ 的性能显得捉襟见肘, 搭建一个RabbitMQ 集群才是解决实际问题的关键 . 二
【RabbitMQ】MQ的基本概念、RabbitMQ简介及安装
热门推荐
十八岁讨厌编程的博客
01-11 2万+
本文涉及MQ的基本概念、RabbitMQ简介、RabbitMQ的安装等内容
MQ消息队列（二）RabbitMQ
zoro_soro的博客
02-09 1189
首先了解RabbitMQ的成员 Producer：生产者，将消息发送到Exchange； Exchange：交换器，将从生产者收到的消息路由到Queen; Queen：存放消费者消费的消息； Consumer：消费者，从Queen中获取消息； BindingKey：绑定键，Exchange与Queen之间的的配置，换句话说就是Exchange将怎样的消息路由到Queen； RoutingKey：路由键，Producer（生产者)将消息与路由键发送给Exchange(交换器)，交换器对比Bin..
实战：实现缓存和数据库一致性方案：mysql+canal+rabbitmq+redis
2301_78526383的博客
06-12 940
最近不是正好在研究 canal 嘛，刚巧前两天看了一篇关于的文章，里边提到了一种解决方案是结合 canal 来操作的，所以阿Q就想趁热打铁，手动来实现一下。
RabbitMQ配置从数据库获取，并可动态创建虚拟机和队列并绑定
z275598733的博客
11-12 4284
首先建三张表并对应三个实体文件：rabbitmq_connect，rabbitmq_exchange， rabbitmq_queue；另外rabbitmq_producer_message_record（记录表可选） #rabbitmq连接信息 CREATE TABLE `rabbitmq_connect` ( `id` bigint NOT NULL, `name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT
RabbitMQ——消息存储
hncscwc的博客
05-28 1708
【概述】前一篇文章中提到了消息可存储在队列索引或消息存储中，对于消息存储的方式，整体框架大概如下图所示：rabbitmq启动后针对每个vhost会启动两个进程：msg_store_per...
如何使用RabbitMQ保证缓存和数据库数据一致性
05-24
使用RabbitMQ可以实现缓存和数据库的数据一致性，具体流程如下： 1. 当数据更新时，先将数据更新到数据库中。 2. 然后在将消息发送到消息队列中，消息队列中的消息包含了数据变更的类型、ID、时间戳等信息。 3. 缓存订阅消息队列中的消息，当接收到数据变更消息时，缓存就会根据消息中的信息来更新缓存中的数据。 4. 如果缓存中没有该数据，或者缓存过期了，就会从数据库中获取最新的数据并更新缓存。 这样，即使缓存中的数据过期或者被删除，也可以通过消息队列中的数据变更消息来及时更新缓存。同时，由于数据库和消息队列的更新是原子性的，因此能够保证数据的一致性。 需要注意的是，由于消息队列可能会出现延迟等问题，因此不能完全依赖消息队列来保证数据的实时性。如果需要保证数据的实时性，可以在更新数据库时同时更新缓存，这样可以尽可能减少缓存过期或者数据不一致的情况。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值