RabbitMQ实战

已于 2023-07-27 20:06:19 修改
阅读量1k 收藏
点赞数
文章标签： rabbitmq 分布式
于 2023-07-25 22:24:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48512649/article/details/131926473
版权

导入依赖

<!--rabbitmq java客户端依赖-->
    <dependencies>
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.6.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

配置文件

#RabbitMQ
  rabbitmq:
    #服务器
    host: 127.0.0.1
    #用户名
    username: guest
    #密码
    password: guest
    #虚拟主机
    virtual-host: /
    #端口
    port: 5672
    listener:
      simple:
        #消费者最小数量
        concurrency: 10
        #消费者最大数量
        max-concurrency: 10
        #限制消费者每次只能处理一条消息，处理完在继续下一条消息
        prefetch: 1
        #启动是默认启动容器
        auto-startup: true
        #被拒绝时重新进入队列
        default-requeue-rejected: true
    template:
      retry:
        #发布重试，默认false
        enabled: true
        #重试时间，默认1000ms
        initial-interval: 1000ms
        #重试最大次数，默认3次
        max-attempts: 3
        #最大重试间隔时间
        max-interval: 10000ms
        #重试的间隔乘数，比如配2.0  第一次等10s 第二次等20s 第三次等40s
        multiplier: 1

生产者代码

package com.itheima.producer;
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_HelloWorld {
    public static void main(String[] args) throws IOException, TimeoutException {

      //1.创建连接工厂
      ConnectionFactory factory=new ConnectionFactory();
      //2.设置参数
        factory.setHost("192.168.101.22");//ip地址 默认localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
        factory.setUsername("heima");//用户名 默认guest
        factory.setPassword("heima");//密码 默认guest
       //3.创建连接 connection
        Connection connection = factory.newConnection();
       //4.创建信道
        Channel channel = connection.createChannel();
        /*
        *创建交换机
        *1.交换机名称
        *2.交换机类型，direct,topic,fanout,headers
        *3.指定交换机是否需要持久化，如果设置为true，那么交换机的元数据要持久化
        *4.指定交换机在没有队列绑定时，是否需要删除，设置false表示不删除
        *5.Map<String,Object>类型，用来指定我们交换机其他的一些机构化参数，我们这里直接设置成null
        */
        channl.exchangeDeclare("xc_exchange_name",BulitinExchangeType.DIRECT,true,false,null);
        
        //5.创建队列Queue 
        /*
        String queue, boolean durable, boolean exclusive, boolean autoDelete,
                                 Map<String, Object> arguments)
        1.queue 队列名称
        2.durable 是否持久化，当mq重启之后，还在 ——  这里的持久化只是队列名称等这些元素数据的持久化，不是队列中消息的持久化
        3.exclusive：表示队列是不是私有的，如果是私有的，只有创建他的应用程序才能消费消息
             *是否独占：只能有一个消费者监听队列
             *当connection关闭时，是否删除队列
        4.autoDelete: 是否自动删除，当没有消费者订阅的情况下consumer时，自动删除掉
        5.arguments: 队列的一些结构化信息，比如声明死信队列，磁盘队列会用到
         */
        //如果没有一个名字为hello_world的队列，则会创建队列，如果有则不会创建
        channel.queueDeclare("hello_world",true,false,false,null);

      /*将队列和交换机绑定
      *1.路由键，这里是队列名称
      *2.交换机名称
      *3.路由键，在直连模式下，可以为我们的队列名称
      */
      channel.queueBind("hello_world","xc_exchange_name","hello_world");
      //6.发送消息
        /*
        String exchange, String routingKey, boolean mandatory, byte[] body
        参数：
            1. exchange：交换机名称，简单模式下交换机会使用默认的 ""
            2. 队列名称
            3. props: 配置信息
            4. body: 发送消息数据
         */
        String body="hello rabbitmq----";
        channel.basicPublish("xc_exchange_name","hello_world",null,body.getBytes());
        //7.释放资源
        channel.close();
        connection.close();
        
    }
}

消费者

package com.itheima.producer;
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 Consumer_HelloWorld {
    public static void main(String[] args) throws IOException, TimeoutException {

      //1.创建连接工厂
      ConnectionFactory factory=new ConnectionFactory();
      //2.设置参数
        factory.setHost("192.168.101.22");//ip地址 默认localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
        factory.setUsername("heima");//用户名 默认guest
        factory.setPassword("heima");//密码 默认guest
       //3.创建连接 connection
        Connection connection = factory.newConnection();
       //4.创建信道
        Channel channel = connection.createChannel();

     //接收消息的回调函数
     DeliverCallback deliverCallback = (consumerTage,message) -> {
           System.out.println("接收到消息" + new String(message.getBody()));
     };

     //取消消息的回调函数
     CancelCallback cancelCallback = consumerTage -> {
           System.out.println("消费消息被中断");
     };
               
      /*
      *消费消息
      *1.消费哪个队列
      *2.消费成功之后是否需要自动应答，true：自动应答
      *3.接受消息的回调函数
      *4.取消消息的回调函数
      */
      channel.basicConsume("hello_world",true,deliverCallback,cancelCallback);
      
    }
}

交换机类型

direct

同一个key (路由键) 可以绑定多个queue队列，当匹配到key1时，与key1绑定的queue1和queue2都可以接收到消息

fanout

Fanout,扇出类型交换机，此种交换机，会将消息发布给所有绑定了此交换机的队列，此时RoutingKey （路由键参数）无效

topic

主题类型交换机，与direct类似，也是需要routingkey路由键进行匹配分发，区别在于topic可以进行模糊匹配，direct是精确匹配

  1. 将routingkey通过" . "分为多个部分
  2. " * "代表一个部分
  3. " # "代表0个或多个部分（如果绑定的路由键为 " # " 时，则接收所有消息，因为路由键所有都匹配）
Headers

与direct交换机完全一致，但是性能差很多不用了

package com.example.seckilldemo.rabbitmq;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 消息发送者
 *
 * @author: LC
 * @date 2022/3/7 7:42 下午
 * @ClassName: MQSender
 */
@Service
@Slf4j
public class MQSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;


    /**
     * 发送秒杀信息
     * @author LiChao
     * @operation add
     * @date 6:44 下午 2022/3/8
     * @param message
     * @return void
     **/
    public void sendSeckillMessage(String message) {
        log.info("发送消息" + message);
        rabbitTemplate.convertAndSend("seckillExchange", "seckill.message", message);
    }


    public void send(Object msg) {
        log.info("发送消息：" + msg);
//        rabbitTemplate.convertAndSend("queue", msg);
        rabbitTemplate.convertAndSend("fanoutExchange", "", msg);
    }
//
//
//    public void send01(Object msg) {
//        log.info("发送red" + msg);
//        rabbitTemplate.convertAndSend("directExchange", "queue.red", msg);
//    }
//
//    public void send02(Object msg) {
//        log.info("发送red" + msg);
//        rabbitTemplate.convertAndSend("directExchange", "queue.green", msg);
//    }
//
//
//    public void send03(Object msg) {
//        log.info("发送消息(QUEUE01接收)：" + msg);
//        rabbitTemplate.convertAndSend("topicExchange", "queue.red.message", msg);
//    }
//
//
//    public void send04(Object msg) {
//        log.info("发送消息(QUEUE02接收)：" + msg);
//        rabbitTemplate.convertAndSend("topicExchange", "green.queue.green.message", msg);
//    }
//
//
//    public void send05(String msg) {
//        log.info("发送消息(QUEUE01和QUEUE02接收)：" + msg);
//        MessageProperties properties = new MessageProperties();
//        properties.setHeader("color", "red");
//        properties.setHeader("speed", "fast");
//        Message message = new Message(msg.getBytes(), properties);
//        rabbitTemplate.convertAndSend("headersExchange", "", message);
//    }
//
//    public void send06(String msg) {
//        log.info("发送消息(QUEUE01接收)：" + msg);
//        MessageProperties properties = new MessageProperties();
//        properties.setHeader("color", "red");
//        properties.setHeader("speed", "normal");
//        Message message = new Message(msg.getBytes(), properties);
//        rabbitTemplate.convertAndSend("headersExchange", "", message);
//    }


}

package com.example.seckilldemo.rabbitmq;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.seckilldemo.entity.TSeckillOrder;
import com.example.seckilldemo.entity.TUser;
import com.example.seckilldemo.service.ITGoodsService;
import com.example.seckilldemo.service.ITOrderService;
import com.example.seckilldemo.service.ITSeckillOrderService;
import com.example.seckilldemo.utils.JsonUtil;
import com.example.seckilldemo.vo.GoodsVo;
import com.example.seckilldemo.vo.RespBean;
import com.example.seckilldemo.vo.RespBeanEnum;
import com.example.seckilldemo.vo.SeckillMessage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

/**
 * 消息消费者
 *
 * @author: LC
 * @date 2022/3/7 7:44 下午
 * @ClassName: MQReceiver
 */
@Service
@Slf4j
public class MQReceiver {

    @Autowired
    private ITGoodsService itGoodsServicel;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private ITOrderService itOrderService;


    /**
     * 下单操作
     *
     * @param
     * @return void
     * @author LiChao
     * @operation add
     * @date 6:48 下午 2022/3/8
     **/
    @RabbitListener(queues = "seckillQueue")
    public void receive(String message) {
        log.info("接收消息：" + message);
        SeckillMessage seckillMessage = JsonUtil.jsonStr2Object(message, SeckillMessage.class);
        Long goodsId = seckillMessage.getGoodsId();
        TUser user = seckillMessage.getTUser();
        GoodsVo goodsVo = itGoodsServicel.findGoodsVobyGoodsId(goodsId);
        if (goodsVo.getStockCount() < 1) {
            return;
        }
        //判断是否重复抢购
        TSeckillOrder tSeckillOrder = (TSeckillOrder) redisTemplate.opsForValue().get("order:" + user.getId() + ":" + goodsId);
        if (tSeckillOrder != null) {
            return;
        }
        //下单操作
        itOrderService.secKill(user, goodsVo);

    }


//    @RabbitListener(queues = "queue")
//    public void receive(Object msg) {
//        System.out.println("接收到的消息" + msg);
//    }
//
//
//    @RabbitListener(queues = "queue_fanout01")
//    public void receive01(Object msg) {
//        log.info("QUEUE01接收消息" + msg);
//    }
//
//    @RabbitListener(queues = "queue_fanout02")
//    public void receive02(Object msg) {
//        log.info("QUEUE02接收消息" + msg);
//    }
//
//    @RabbitListener(queues = "queue_direct01")
//    public void receive03(Object msg) {
//        log.info("QUEUE01接收消息" + msg);
//    }
//
//    @RabbitListener(queues = "queue_direct02")
//    public void receive04(Object msg) {
//        log.info("QUEUE02接收消息" + msg);
//    }
//
//    @RabbitListener(queues = "queue_topic01")
//    public void receive05(Object msg) {
//        log.info("QUEUE01接收消息" + msg);
//    }
//
//    @RabbitListener(queues = "queue_topic02")
//    public void receive06(Object msg) {
//        log.info("QUEUE02接收消息" + msg);
//    }
//
//    @RabbitListener(queues = "queue_header01")
//    public void receive07(Message message) {
//        log.info("QUEUE01接收消息 message对象" + message);
//        log.info("QUEUE01接收消息" + new String(message.getBody()));
//    }
//
//    @RabbitListener(queues = "queue_header02")
//    public void receive08(Message message) {
//        log.info("QUEUE02接收消息 message对象" + message);
//        log.info("QUEUE02接收消息" + new String(message.getBody()));
//    }

}

package com.example.seckilldemo.controller;

import com.example.seckilldemo.entity.TUser;
import com.example.seckilldemo.rabbitmq.MQSender;
import com.example.seckilldemo.service.ITUserService;
import com.example.seckilldemo.utils.MD5Util;
import com.example.seckilldemo.vo.RespBean;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 用户表 前端控制器
 * </p>
 *
 * @author LiChao
 * @since 2022-03-02
 */
@RestController
@RequestMapping("/user")
@Api(value = "用户表", tags = "用户表")
public class TUserController {


    @Autowired
    private ITUserService tUserService;
    @Autowired
    private MQSender mqSender;

    @RequestMapping(value = "/info", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation("返回用户信息")
    public RespBean info(TUser user) {
        return RespBean.success(user);
    }

    //测试发送RabbitMQ消息
    @RequestMapping(value = "/mq", method = RequestMethod.GET)
    @ResponseBody
    public void mq() {
        mqSender.send("Hello");
    }
//
//    @RequestMapping(value = "/mq/fanout", method = RequestMethod.GET)
//    @ResponseBody
//    public void mqFanout() {
//        mqSender.send("Hello");
//    }
//
//    @RequestMapping(value = "/mq/direct01", method = RequestMethod.GET)
//    @ResponseBody
//    public void mqDirect01() {
//        mqSender.send01("Hello Red");
//    }
//
//    @RequestMapping(value = "/mq/direct02", method = RequestMethod.GET)
//    @ResponseBody
//    public void mqDirect02() {
//        mqSender.send02("Hello Green");
//    }
//
//    @RequestMapping(value = "/mq/topic01", method = RequestMethod.GET)
//    @ResponseBody
//    public void mqtopic01() {
//        mqSender.send03("Hello Red");
//    }
//
//    @RequestMapping(value = "/mq/topic02", method = RequestMethod.GET)
//    @ResponseBody
//    public void mqtopic02() {
//        mqSender.send04("Hello Green");
//    }
//
//    @RequestMapping(value = "/mq/header01", method = RequestMethod.GET)
//    @ResponseBody
//    public void header01() {
//        mqSender.send05("Hello 01");
//    }
//
//    @RequestMapping(value = "/mq/header02", method = RequestMethod.GET)
//    @ResponseBody
//    public void header02() {
//        mqSender.send06("Hello 02");
//    }


    @GetMapping("/createuser")
    @ApiOperation("压测创建配置文件")
    public void CreateUser() throws IOException {
        List<TUser> list = new ArrayList<>();
        //生成用户
//        for (int i = 0; i < 100; i++) {
//            TUser tUser = new TUser();
//            tUser.setId(1233L + i);
//            tUser.setNickname("user" + i);
//            tUser.setSalt("1a2b3c");
//            tUser.setPassword("05314c6fbe1d0cdb5eab4e80f1bda30a");
//            list.add(tUser);
//        }
//        tUserService.saveBatch(list);
//        System.out.println("create user");

        //读取用户
        list = tUserService.list();

        //登录，生成UserTicket
        String urlString = "http://localhost:8080/login/doLogin";
        File file = new File("/Users/lichao/Downloads/config.txt");
        if (file.exists()) {
            file.delete();
        }
        RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
        randomAccessFile.seek(0);
        for (int i = 0; i < list.size(); i++) {
            TUser tUser = list.get(i);
            URL url = new URL(urlString);
            HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
            httpURLConnection.setRequestMethod("POST");
            httpURLConnection.setDoOutput(true);
            OutputStream outputStream = httpURLConnection.getOutputStream();
            String params = "mobile=" + tUser.getId() + "&password=c38dc3dcb8f0b43ac8ea6a70b5ec7648";
            outputStream.write(params.getBytes());
            outputStream.flush();
            InputStream inputStream = httpURLConnection.getInputStream();
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] buff = new byte[1024];
            int len = 0;
            while ((len = inputStream.read(buff)) >= 0) {
                byteArrayOutputStream.write(buff, 0, len);
            }
            inputStream.close();
            byteArrayOutputStream.close();
            String respone = new String(byteArrayOutputStream.toByteArray());
            ObjectMapper mapper = new ObjectMapper();
            RespBean respBean = mapper.readValue(respone, RespBean.class);
            String userTicket = (String) respBean.getObject();
            System.out.println("create userTicket:" + tUser.getId());
            String row = tUser.getId() + "," + userTicket;
            randomAccessFile.seek(randomAccessFile.length());
            randomAccessFile.write(row.getBytes());
            randomAccessFile.write("\r\n".getBytes());
            System.out.println("write to file :" + tUser.getId());
        }
        randomAccessFile.close();
        System.out.println();
    }
}
Lazy龙
关注
rabbitmq web服务忘记用户名和密码的解决方案
duan_3826的博客
11-01 6803
rabbitmq web服务忘记用户名和密码的解决方案 忘记账号密码，需要新增一个管理员账号，然后进去修改账号密码 在服务器上运行以下命令即可： rabbitmqctl add_user newadmin newpassword rabbitmqctl set_user_tags newadmin administrator rabbitmqctl set_permissions -p / newadmin ".*" ".*" ".*" newadmin为新管理员账号，newpassword为密码 ,
RabbitMQ新建管理员账号的批处理.bat
09-06
RabbitMQ新建管理员账号的批处理，用于一键新建管理员账号
RabbitMQ 修改默认密码
qq_41497074的博客
06-25 1740
RabbitMQ默认账号名是guest，密码也是guest。这意味着访问者无需任何验证就可以登录并访问RabbitMQ。这是一种非常危险和不安全的配置，因为任何人都可以登录并访问您的RabbitMQ服务器并读取或发送数据。因此，务必在安装RabbitMQ后更改默认账号名和密码。不要使用弱密码，并且强烈建议启用身份验证机制。
RabbitMQ用户管理
在路上的羊先森
08-01 6143
上一篇章介绍如何安装RabbitMQ并设置为windows的服务，有兴趣的可以点击此处查看，安装好的RabbitMQ提供了一个默认的guest账户，单独这一个账户是无法满足日常的管理需求，所以用户管理就显得非常有必要了。超级管理员，可登陆管理控制台(启用managementplugin的情况下)，可查看所有的信息，并且可以对用户，策略(policy)进行操作。普通管理者，仅可登陆管理控制台(启用managementplugin的情况下)，无法看到节点信息，也无法对策略进行管理。......
查找openstack的rabbitmq用户名密码和端口号
崔崇鑫的博客，你linux/云运维工作中的百科全书。
05-11 1万+
文章目录rabbit配置文件中途查找用户名和密码登陆方式管理端口查看Set default valuesSet default values用户名查看方式一：方式二计算节点查看查看rabbitmq服务 rabbit配置文件中途查找用户名和密码 登陆方式 一般控制节点加端口(0.0.0.0:15672)就是rabbitmq 的 登陆地址。15672是默认端口。（顺便说一下，rabbitmq只要配置了，所有的控制节点加端口都是可以到这个界面的，并且内容一样） 我用的是火狐浏览器。 顺便说一下，rabbitmq
Rabbitmq用户名密码
IamstudyingJava的专栏
07-19 3856
为该用户设置权限所有权限：rabbitmqctl set_permissions -p / username".*" ".*" ".*"设置该用户为管理员角色：rabbitmqctl set_user_tags username administrator。1、有个默认的用户名密码guest，但是这个只能通过本地连接，如果在java的rabbitmq连接，会报错。3、查看所有用户：rabbitmqctl list_users。4、配置文件 rabbitmq.config。2、添加用户以及授权。
rabbitmq常用命令
qq_28625901的博客
09-18 220
rabbitmq的web管理界面无法使用guest用户登录 安装最新版本的rabbitmq(3.3.1)，并启用management plugin后，使用默认的账号guest登陆管理控制台，却提示登陆失败。 翻看官方的release文档后，得知由于账号guest具有所有的操作权限，并且又是默认账号，出于安全因素的考虑，guest用户只能通过localhost登陆使用，并建议修改guest用户的密码以及新建其他账号管理使用rabbitmq(该功能是在3.3.0版本引入的)。 虽然可以以比较猥琐的方式：将ebi
RabbitMq 创建用户
Jifei5201314的博客
09-08 3913
rabbitmqctl set_permissions -p /(虚拟主机地址 ) 用户名 "."(配置正则表达式) "."(写正则表达式) ".*"(阅读正则表达式)4.administrator：用户可以做任何监控可以做的事情，管理用户、虚拟主机和权限，关闭其他用户的连接，以及管理所有虚拟主机的策略和参数。2.policymaker：用户可以访问管理插件并管理他们有权访问的虚拟主机的策略和参数。3.monitoring：用户可以访问管理插件并查看所有连接和通道以及节点相关信息。一、创建用户名和密码。
docker查看rabbitmq账号密码
最新发布
weixin_37004909的博客
08-16 47
我整理的一些关于【Docker】的项目学习资料（附讲解～～）和大家一起分享、学习一下：https://d.51cto.com/f2PFnN如何在Docker中查看RabbitMQ的账号密码 RabbitMQ 是一个广泛使用的消息队列系统，Docker 则提供了一种轻松部署和管理 RabbitMQ 的方式。当你使用 Doc...
RabbitMQ实战指南-rabbitmq-action.zip
11-07
**RabbitMQ实战指南** RabbitMQ是一款广泛应用的开源消息队列系统，它基于Advanced Message Queuing Protocol（AMQP）标准，提供高可用性、可靠性和可扩展性。本实战指南将带你深入理解RabbitMQ的核心概念、安装与...
rabbitMQ实战java版-rabbitMQ-demo.zip
11-07
《RabbitMQ实战Java版——基于rabbitMQ-demo.zip的详解》 在当今的分布式系统中，消息队列作为异步处理、解耦组件的关键技术，得到了广泛应用。RabbitMQ作为一款开源的消息代理和队列服务器，以其稳定性和易用性...
RabbitMQ实战指南.7z
11-30
RabbitMQ 是目前非常热门的一款消息中间件，不管是互联网行业还是传统行业都在大量 地使用 RabbitMQ 凭借其高可靠、易扩展、高可用及丰富的功能特性受到越来越多企业的青 作为一个合格的开发者，有必要深入地...
rabbitMQ实战
10-10
### RabbitMQ实战知识点详解 #### 一、RabbitMQ简介及背景 - **RabbitMQ开发语言**: Erlang，一种面向并发的编程语言，非常适合处理大量并发连接。 - **AMQP**: 先进的消息队列协议（Advanced Message Queuing ...
怎么查看rabbitmq的用户名与密码以及解决配置找不到的问题
weixin_46361294的博客
09-08 1万+
可以查看到所有的用户，可以看到哪些用户是被赋有了管理员权限，网上有一些查找配置文件rabbitmq.conf的文件，但是电脑里面并没有这个文件，于是就重新创建一个账户并赋值；问题：在RABBITMQ页面发现没有配置文件（/etc/rabbitmq/rabbitmq.config (not found)）配置文件没有找到。问题：登录前人设置的rabbitmq，现在不知道密码。解决办法：使用命令对模板进行复制。，假如模板没有解压的话使用命令。解压，之后再执行重启命令。给新用户赋以管理权限。
Rabbitmq 安全账号管理方案
屈帅波的技术博客
03-07 2602
第一方案 创建与业务相关的账号及vhost，添加自定义权限 rabbitmqctl add_vhost host rabbitmqctl add_user admin 123456 rabbitmqctl set_permissions -p host admin ".*" ".*" ".*" 只对其相关联的应用有管理的权限 风险：目前的线上连接rabbitmq 的账号大多是administrator 角色的账号，如果修改为低级别的权限，如果交叉访问vhost，必然会有权限问题； rabb
【Rabbitmq详解】
qq_47592482的博客
04-04 8156
1.消息中间件利用可靠些传递机制进行系统和系统之间的通讯.2.通过提供消息队列传递和消息队列排队机制,它可以在分布式系统架构上扩展进程之间的通讯.
rabbitmq 默认用户和密码
热门推荐
butterfly2017的博客
05-24 2万+
Note:The default administrator username and password areguestandguest.
rabbitmq windows修改密码
07-28
在 Windows 系统中修改 RabbitMQ 的密码，可以按照以下步骤进行操作： 1. 打开命令提示符或 PowerShell 窗口。 2. 切换到 RabbitMQ Server 的安装目录下的 sbin 文件夹。例如，如果 RabbitMQ 安装在 C 盘的 Program Files 文件夹下，则需要执行以下命令切换目录：`cd C:\Program Files\RabbitMQ Server\rabbitmq_server-{version}\sbin`，其中 `{version}` 是 RabbitMQ 的版本号。 3. 使用以下命令停止 RabbitMQ 服务：`rabbitmq-service stop`。 4. 使用以下命令重置 RabbitMQ 用户的密码：`rabbitmqctl.bat change_password <Username> <NewPassword>`，将 `<Username>` 替换为要重置密码的用户名，将 `<NewPassword>` 替换为新的密码。 5. 使用以下命令启动 RabbitMQ 服务：`rabbitmq-service start`。 完成以上步骤后，你的 RabbitMQ 用户的密码就会被修改为新的密码。请确保在执行命令时按照正确的语法和参数进行替换。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值