【Java秒杀方案】4. rabbitMQ 3.8.5安装 erlang_23 jdk1.8 centos7 Springboot 集成 starter Exchange RabbitMQConfig

最新推荐文章于 2024-06-13 11:22:20 发布
最新推荐文章于 2024-06-13 11:22:20 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： java电商秒杀方案 文章标签： rabbitmq spring boot erlang java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alwarse/article/details/121624032
版权

RabbitMQ安装

官方教程 getstarted

https://www.rabbitmq.com/getstarted.html
在这里插入图片描述
Routing Receiving messages selectively
在这里插入图片描述
Topics Receiving messages based on a pattern (topics)
在这里插入图片描述

RPC Request/reply pattern
在这里插入图片描述

1.在线安装依赖环境：

yum install build-essential openssl openssl-devel unixODBC unixODBC-devel make gcc gcc-c++ kernel-devel m4 ncurses-devel tk tc xz

2.安装Erlang

官网提示：https://www.erlang-solutions.com/resources/download.html

2.1esl-erlang_23.0.2-1_centos_7_amd64.rpm 下载

链接：https://pan.baidu.com/s/1w3zpv8iR1E5bs7m9EogYig
提取码：orqm

2.2 安装erlang

yum -y install esl-erlang_23.0.2-1_centos_7_amd64.rpm

2.3 检测erlang

erl

[root@seckill rabbitmq]# erl
Erlang/OTP 23 [erts-11.0.2] [source] [64-bit] [smp:2:2] [ds:2:2:10] [async-threads:1] [hipe]

Eshell V11.0.2  (abort with ^G)

3. 安装RabbitMQ

官网下载地址：http://www.rabbitmq.com/download.html

3.1 下载

链接：https://pan.baidu.com/s/1MZUispijy1F0Gh-EXJUrVA
提取码：5qdp

3.2 安装rabbitmq

yum -y install rabbitmq-server-3.8.5-1.el7.noarch.rpm

3.3 安装UI插件

rabbitmq-plugins enable rabbitmq_management

3.4 启用rabbitmq服务

systemctl start rabbitmq-server.service

3.5 安装UI插件时报错异常解决

错误

{:query, :rabbit@seckill, {:badrpc, :timeout}}

方法：需要设置自己的hostname

[root@seckill rabbitmq]# hostnamectl
   Static hostname: seckill
         Icon name: computer-vm
		 
[root@seckill rabbitmq]# vi /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
192.168.25.130 seckill

3.6 检测服务

systemctl status rabbitmq-server.service

3.7 web访问

guest/guest 用户默认只可以localhost(本机)访问

localhost:15672

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

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

3.8 安装路径 whereis rabbitmq

/usr/lib/rabbitmq/lib/rabbitmq_server-3.8.5

3.9 默认配置文件 guest/guest 远程访问授权

/etc/rabbitmq/rabbitmq.config
在rabbitmq的配置文件目录下（默认为：/etc/rabbitmq）创建一个rabbitmq.config文件。
文件中添加如下配置（请不要忘记那个“.”）：

[{rabbit, [{loopback_users, []}]}].

重启rabbitmq服务

重新访问

4.springboot 集成使用

4.1 依赖

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

4.2 RabbitMQConfig.java com.example.miaosha.config

4.2.1 测试 fanoutExchange

广播 全部queue都收到
在这里插入图片描述

4.2.2 测试 direct_Exchange ROUTINGKEY01(queue.red)

依据绑定的路由key,转到到指定queue

在这里插入图片描述

4.2.3 测试 topic_Exchange TOPICROUTINGKEY01("#.queue.#" “.queue.”)

依据路由规则，*,#通配符 *表示 1各或者多个 *表示0次或多次
在这里插入图片描述

4.2.4 测试 head_Exchange

在这里插入图片描述

匹配map中的值 match

4.2.5 RabbitMQConfigTest .java com.example.miaosha.config
package com.example.miaosha.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;
@Configuration
public class RabbitMQConfigTest {
    private static final  String QUEUE01="queue_fanout01";
    private static final  String QUEUE02="queue_fanout02";
    private static final  String EXCHANGE="fanoutExchange";

    private static final  String DIRCTQUEUE01="direct_queue01";
    private static final  String DIRCTQUEUE02="direct_queue02";
    private static final  String DIRCTEXCHANGE="direct_Exchange";
    private static final  String ROUTINGKEY01="queue.red";
    private static final  String ROUTINGKEY02="queue.green";

    private static final  String TOPICQUEUE01="topic_queue01";
    private static final  String TOPICQUEUE02="topic_queue02";
    private static final  String TOPICEXCHANGE="topic_Exchange";
    private static final  String TOPICROUTINGKEY01="#.queue.#";
    private static final  String TOPICROUTINGKEY02="*.queue.*";

    private static final  String HEADQUEUE01="head_queue01";
    private static final  String HEADQUEUE02="head_queue02";
    private static final  String HEADEXCHANGE="head_Exchange";


    @Bean
    //生产者 消费者
    public Queue queue(){
        return new Queue("q1",true);
    }

    @Bean
    public Queue queue01(){
        return new Queue(QUEUE01);
    }

    @Bean
    public Queue queue02(){
        return new Queue(QUEUE02);
    }

    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange(EXCHANGE);
    }

    @Bean
    public Binding Binding01(){
        return BindingBuilder.bind(queue01()).to(fanoutExchange());
    }

    @Bean
    public Binding Binding02(){
        return BindingBuilder.bind(queue02()).to(fanoutExchange());
    }


    @Bean
    public Queue directQueue01(){
        return new Queue(DIRCTQUEUE01);
    }

    @Bean
    public Queue directQueue02(){
        return new Queue(DIRCTQUEUE02);
    }

    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange(DIRCTEXCHANGE);
    }

    @Bean
    public Binding directBinding01(){
        return BindingBuilder.bind(directQueue01()).to(directExchange()).with(ROUTINGKEY01);
    }

    @Bean
    public Binding directBinding02(){
        return BindingBuilder.bind(directQueue02()).to(directExchange()).with(ROUTINGKEY02);
    }


    @Bean
    public Queue topicQueue01(){
        return new Queue(TOPICQUEUE01);
    }

    @Bean
    public Queue topicQueue02(){
        return new Queue(TOPICQUEUE02);
    }

    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(TOPICEXCHANGE);
    }

    @Bean
    public Binding topicBinding01(){
        return BindingBuilder.bind(topicQueue01()).to(topicExchange()).with(TOPICROUTINGKEY01);
    }

    @Bean
    public Binding topicBinding02(){
        return BindingBuilder.bind(topicQueue02()).to(topicExchange()).with(TOPICROUTINGKEY02);
    }


    @Bean
    public Queue headQueue01(){
        return new Queue(HEADQUEUE01);
    }

    @Bean
    public Queue headQueue02(){
        return new Queue(HEADQUEUE02);
    }

    @Bean
    public HeadersExchange headExchange(){
        return new HeadersExchange(HEADEXCHANGE);
    }

    @Bean
    public Binding headBinding01(){
        Map<String,Object> map=new HashMap<>();
        map.put("color","red");
        map.put("speed","low");
        return BindingBuilder.bind(headQueue01()).to(headExchange()).whereAll(map).match();
    }

    @Bean
    public Binding headBinding02(){
        Map<String,Object> map=new HashMap<>();
        map.put("color","red");
        map.put("speed","fast");
        return BindingBuilder.bind(headQueue02()).to(headExchange()).whereAll(map).match();
    }


}
4.2.5 RabbitMQConfig .java com.example.miaosha.config

实际秒杀用到的TopicExchange配置

package com.example.miaosha.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class RabbitMQConfig {

    private static final  String QUEUE="seckillQueue";
    private static final  String EXCHANGE="seckillExchange";
    private static final  String ROUTINGKEY="seckill.#";



    @Bean
    public Queue seckillQueue(){
        return new Queue(QUEUE);
    }


    @Bean
    public TopicExchange seckillExchange(){
        return new TopicExchange(EXCHANGE);
    }

    @Bean
    public Binding binding(){
        return BindingBuilder.bind(seckillQueue()).to(seckillExchange()).with(ROUTINGKEY);
    }


}

4.3 MQReceiver .java com.example.miaosha.rabbitmq

通过 @RabbitListener(queues = “seckillQueue”) 绑定queue
通过fastjson 把 String message 转为SeckillMessage对象使用

package com.example.miaosha.rabbitmq;

import com.alibaba.fastjson.JSON;
import com.example.miaosha.pojo.SeckillMessage;
import com.example.miaosha.pojo.SeckillOrder;
import com.example.miaosha.pojo.User;
import com.example.miaosha.service.IGoodsService;
import com.example.miaosha.service.IOrderService;
import com.example.miaosha.utils.JsonUtil;
import com.example.miaosha.vo.GoodsVo;
import com.example.miaosha.vo.RespBean;
import com.example.miaosha.vo.RespBeanEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestMapping;

@Service
@Slf4j
public class MQReceiver {

    @Autowired
    private IGoodsService goodsService;
    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private IOrderService orderService;

    @RabbitListener(queues = "seckillQueue")
    public void receive(String message){
        log.info("seckillQueue接受消息:"+message);
        SeckillMessage seckillMessage = JSON.parseObject(message, SeckillMessage.class);
        Long goodsId = seckillMessage.getGoodsId();
        User user = seckillMessage.getUser();
        //下单操作
        GoodsVo goodsVo = goodsService.findGoodsVoById(goodsId);
        if(goodsVo.getStockCount()<1){
            //如果有key,表示，没有库存，结束
            redisTemplate.opsForValue().set("isStockEmpty:"+goodsId,"0");
            return;
        }

        //1. 判断是否重复抢购
        ValueOperations valueOperations = redisTemplate.opsForValue();
        SeckillOrder seckillOrder = (SeckillOrder)valueOperations.get("order:" + user.getId() + ":" + goodsId);

        if(null!=seckillOrder){
            return;
        }
        //重复抢购
        orderService.seckill(goodsVo,user);

    }


    /*
    @RabbitListener(queues = "q1")
    public void receive(Object msg){
        log.info("接受消息:"+msg);
    }

    @RabbitListener(queues = "queue_fanout01")
    public void receive1(Object msg){
        log.info("queue_fanout01接受消息:"+msg);
    }

    @RabbitListener(queues = "queue_fanout02")
    public void receive2(Object msg){
        log.info("queue_fanout02接受消息:"+msg);
    }

    @RabbitListener(queues = "direct_queue01")
    public void receive3(Object msg){
        log.info("direct_queue01接受消息:"+msg);
    }

    @RabbitListener(queues = "direct_queue02")
    public void receive4(Object msg){
        log.info("direct_queue02接受消息:"+msg);
    }

    @RabbitListener(queues = "topic_queue01")
    public void receive5(Message msg){
        log.info("topic_queue01接受消息:"+msg);
    }

    @RabbitListener(queues = "topic_queue02")
    public void receive6(Message msg){
        log.info("topic_queue02接受消息:"+msg);
    }


    @RabbitListener(queues = "head_queue01")
    public void receive7(Message msg){
        log.info("head_queue01接受消息:"+new String(msg.getBody()));
    }
    @RabbitListener(queues = "head_queue02")
    public void receive8(Message msg){
        log.info("head_queue02接受消息:"+new String(msg.getBody()));
    }
    */

}

4.4 MQSender.java com.example.miaosha.rabbitmq

注入 rabbitTemplate
exchangename:seckillExchange
routerkey:seckill.message
message string
rabbitTemplate.convertAndSend(“seckillExchange”,“seckill.message”,message);

package com.example.miaosha.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;

@Service
@Slf4j
public class MQSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendSeckillMessage(String message){
        log.info("sendSeckill发送消息:"+message);
        rabbitTemplate.convertAndSend("seckillExchange","seckill.message",message);
    }

    /*

    public void send(Object msg){
        log.info("发送消息:"+msg);
        rabbitTemplate.convertAndSend("q1",msg);
    }

    public void sendFanout(Object msg){
        log.info("fanout发送消息:"+msg);
        rabbitTemplate.convertAndSend("fanoutExchange","",msg);
    }

    public void sendDirect01(Object msg){
        log.info("directExchange发送消息:"+msg);
        rabbitTemplate.convertAndSend("direct_Exchange","queue.red",msg);
    }

    public void sendDirect02(Object msg){
        log.info("directExchange发送消息:"+msg);
        rabbitTemplate.convertAndSend("direct_Exchange","queue.green",msg);
    }

    public void sendTopic01(Object msg){
        log.info("topic_Exchange发送消息:"+msg);
        rabbitTemplate.convertAndSend("topic_Exchange","aaa.queue.bbb",msg);
    }

    public void sendTopic02(Object msg){
        log.info("topic_Exchange发送消息:"+msg);
        rabbitTemplate.convertAndSend("topic_Exchange","queue.red.message",msg);
    }

    public void sendHead01(String msg){
        log.info("topic_Exchange发送消息:"+msg);
        MessageProperties properties=new MessageProperties();
        properties.setHeader("color","red");
        properties.setHeader("speed","low");
        Message message=new Message(msg.getBytes(),properties);
        rabbitTemplate.convertAndSend("head_Exchange","",message);
    }

    public void sendHead02(String msg){
        log.info("topic_Exchange发送消息:"+msg);
        MessageProperties properties=new MessageProperties();
        properties.setHeader("color","red");
        properties.setHeader("speed","fast");
        Message message=new Message(msg.getBytes(),properties);
        rabbitTemplate.convertAndSend("head_Exchange","",message);
    }
    */


}

4.5 SeckillController 发送 SeckillMessage

@Controller
@Slf4j
@RequestMapping("/seckill")
public class SeckillController implements InitializingBean {
@Autowired
private MQSender mqSender;

 //秒杀静态化，在商品详情页，直接ajax请求秒杀，成功后，跳转秒杀成功静态页面
    @RequestMapping(value = "/{path}/doSeckill",method = RequestMethod.POST)
    @ResponseBody
    public RespBean doSeckill(Model model, User user,Long goodsId,@PathVariable String path) {
		//下单
        SeckillMessage seckillMessage = new SeckillMessage(user, goodsId);

        mqSender.sendSeckillMessage(JSON.toJSONString(seckillMessage));

        //正在排队中 0
	    return RespBean.success(0);
	}
}

4.6 SeckillMessage.java com.example.miaosha.pojo

消息对象

package com.example.miaosha.pojo;

import com.example.miaosha.vo.GoodsVo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class SeckillMessage {
    private User user;
    private Long goodsId;
}

4.7发送消息控制器 UserController /user/mq/topic01

package com.example.miaosha.controller;


import com.example.miaosha.pojo.User;
import com.example.miaosha.rabbitmq.MQSender;
import com.example.miaosha.vo.RespBean;
import com.example.miaosha.vo.RespBeanEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author cch
 * @since 2021-11-14
 */
@Controller
@RequestMapping("/user")
public class UserController {
    @Autowired
    private MQSender mqSender;


    @RequestMapping("/info")
    @ResponseBody
    public RespBean info(User user){
        return RespBean.success(user);
    }
    
    @RequestMapping("/mq")
    @ResponseBody
    public void mq(){
        mqSender.send("hello");
    }

    @RequestMapping("/mq/fanout")
    @ResponseBody
    public void fanout(){
        mqSender.sendFanout("hello");
    }

    @RequestMapping("/mq/direct01")
    @ResponseBody
    public void direct01(){
        mqSender.sendDirect01("hello");
    }

    @RequestMapping("/mq/direct02")
    @ResponseBody
    public void direct02(){
        mqSender.sendDirect02("hello");
    }

    @RequestMapping("/mq/topic01")
    @ResponseBody
    public void topic01(){
        mqSender.sendTopic01("hello");
    }


    @RequestMapping("/mq/topic02")
    @ResponseBody
    public void topic02(){
        mqSender.sendTopic02("hello");
    }

    @RequestMapping("/mq/header01")
    @ResponseBody
    public void head01(){
        mqSender.sendHead01("hello red low");
    }

    @RequestMapping("/mq/header02")
    @ResponseBody
    public void head02(){
        mqSender.sendHead02("hello red fast");
    }


}
alwarse
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
centos7 rpm快速安装rabbitmq3.8.5 php安装amqp扩展 添加延迟队列扩展 避开坑
07-27
rabbitmq3.8.5 和下面版本都有一切区别，首先就是erlang语言版本的区别，但还好用的是openssl1.0，不然升级openssl又是一个恶心的事情，相反rabbitmq3.7.2x版本虽然用来erlang22，但是openssl用了1.1，造成不兼容性，一般centos7都是装的openssl1.0版本，该压缩包，给了详细的安装文档，稍微区别于3.7和3.6，已经增加了延迟队列扩展
Erlang-otp_win64_23.0.zip
06-07
rabbitmq安装前的环境安装，Erlang23.0 Windows64安装包，官网下载了几个小时
Centos7安装RabbitMQ最新版3.8.5，史上最简单实用安装步骤
热门推荐
weixin_40584261的博客
06-18 2万+
一、系统环境 1、JDK1.8 2、Centos7.4-64位 3、Erlang-OTP 23 4、RabbitMQ-3.8.5 二、安装Erlang 1、erlang和rabbitmq的版本对应关系 2、通过rpm安装erlang 1）完成erlang的前置条件配置 curl -s https://packagecloud.io/install/repositories/rabbitmq/erlang/script.rpm.sh | sudo bash 2）安装erlang yum install -
Window下安装RabbitMQ3.8.5
emgexgb_sef的博客
04-11 1950
目录 安装Erlang 1.下载Erlang 2.安装并配置环境变量 安装RabbitMQ 1.下载RabbitMQ 2.添加配置文件并修改端口号 3.开启管理插件(Web管理页面) 5.添加RabbitMQ到本地服务 RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。RabbitMQ的版本和Erlang的版本是相对应的，可以去RabbitMQ查看相对应的版本。
win10 安装rabbitMQ详细步骤
正怒月神的博客
03-24 417
转载：https://blog.csdn.net/qq_39915083/article/details/107034747 本次安装环境信息： 系统：win10 64位专业版 erlang：otp_win64_23.0 rabbitMQ：rabbitmq-server-3.8.5 安装rabbitMQ需要依赖erlang语言环境，所以需要我们下载erlang的环境安装程序。 一、下载安装程序 rabbitMQ安装程序下载路径：https://www.rabbitmq.com/..
RabbitMQ的pom文件中客户端依赖版本问题
m0_67391377的博客
04-07 1335
Maven镜像地址：https://mvnrepository.com/ rabbitmq 和 erlang 版本依赖关系 RabbitMQ Erlang Version Requirements — RabbitMQ erlang版本为：OTP 24.1；下载地址为Erlang Programming LanguageErlang Programming Language[这里是图片001]https://www.erlang.org/downloads rabbitmq版本为：3.9.8；下载地址为：D
Centos7下安装RabbitMQ教程
Z1366566161664的博客
02-25 3454
Centos7下安装RabbitMQ教程
Centos7安装RabbitMQ的文档和安装包(包含erlang安装包).rar
04-06
Centos7安装RabbitMQ的文档和安装包，包含erlang的安装文档和安装包。RabbitMQ版本是3.7.12。
erlang-19.0.4-1.el7.centos.x86_64和rabbitmq-server-3.6.6-1.el7
05-12
centos6.5安装rabbitmq所需要的安装包，erlang-19.0.4-1.el7.centos.x86_64.zip rabbitmq-server-3.6.6-1.el7.noarch.rpm
最新版erlang-23.3.4.3-1.el7.x86_64.rpm（CentOS7）
06-15
包括erlang-23.3.4.3-1.el7.x86_64.rpm和rabbitmq-server-3.8.17-1.el7.noarch.rpm以及安装步骤
rabbitmq_delayed_message_exchange-3.9.0.ez
05-09
rabbitmq_delayed_message_exchange-3.9.0.ez
Linux系统中RabbitMQ的安装（rabbitmq-server-3.8.5）
瑶山的博客
07-16 2181
Linux系统中RabbitMQ安装使用 安装Erlang Erlang22.3 由于RabbitMQ依赖Erlang， 所以需要先安装Erlang。 RabbitMQ Erlang版本要求对照表：https://www.rabbitmq.com/which-erlang.html 下载地址：https://www.erlang.org/downloads/22.3 安装erlang依赖环境 yum install -y gcc gcc-c++ unixODBC-devel openssl.
linux RabbitMQ-3.8.5 安装
bug_null的博客
08-19 860
当启用rabbitmq_management插件时，自动启动了依赖的rabbitmq_management_agent插件和rabbitmq_web_dispatch。RabbitMQ安装需要依赖:socat和logrotate，logrotate操作系统已经存在了，只需要安装socat就可以了。RabbitMQ的安装首先需要安装Erlang,因为它是基于Erlang的VM运行的。http://<安装RabbitMQ的机器的IP>:15672。至此RabbitMQ的安装就已经完成。登录成功后，可以看到。
Centos7安装Rabbitmq，仅需要几个命令而已
网尘的技术专栏
08-12 771
1.安装yum源 curl -s https://packagecloud.io/install/repositories/rabbitmq/erlang/script.rpm.sh | sudo bash curl -s https://packagecloud.io/install/repositories/rabbitmq/rabbitmq-server/script.rpm.sh | sudo bash 2.安装Rabbitmq-server yum install rabbitmq-server
rabbitmq 3.6.6集群升级目前最新版本3.8.5
goodsirlee的博客
07-17 2757
背景： 系统为centos 7.2 ,目前使用的rabbitmq版本比较旧，故在测试环境先下验证升级到目前为止的最新版本3.8.5 各版本依赖的erlang不同，详情可见https://www.rabbitmq.com/which-erlang.html 现erlang的版本过低，故还得升级到最新的erlang才行了。 1.卸载相关程序 各节点执行： yum remove -y rabbitmq-server erlang* 2.安装新版本Erlang 不同系统的方法不一样，详情见https://githu
centos7 安装 rabbitmq 3.8.5
loosed的博客
06-19 452
下载rabbitmq 3.8.5 (rabbitmq-server-generic-unix-3.8.5.tar.xz)设置admin为管理员权限。启用Web STOMP。erlang环境配置。
### RabbitMQ五种工作模式：
最新发布
weixin_46597615的博客
06-13 219
4、路由模式：由交换机分发消息，但是发送方需要指定路由key，交换机会根据不同的routing key分发给不同的队列，消费方对应自己需要的队列。5、通配符模式：和路由模式有些相近，只是通配符模式可以在绑定routing key时使用通配符。2、工作队列模式：也是不通过交换机，消息直接通过队列，只是一个发送方可以有多个接收端。3、发布订阅模式：由交换机分发消息到不同队列，每个消费者只监听自己的队列。1、简单模式：就是不通过交换机，消息直接通过队列，一对一收发。
rabbitmq 3.9.14 手动安装 rabbitmq_conf 插件
06-01
好的，以下是手动安装 rabbitmq_conf 插件的步骤： 1. 首先需要下载 rabbitmq_conf 插件的源代码，可以从官方网站上下载到。 2. 解压下载的源代码，将其放置在 RabbitMQ 的 plugins 目录下，通常为 /usr/lib/rabbitmq/plugins。 3. 进入插件源代码的目录，执行以下命令： ``` make ``` 4. 编译成功后，会在当前目录下生成一个 .ez 文件，将该文件复制到 RabbitMQ 的 plugins 目录下即可。 5. 启用插件，执行以下命令： ``` rabbitmq-plugins enable rabbitmq_conf ``` 6. 重启 RabbitMQ 服务，使插件生效。 以上就是手动安装 rabbitmq_conf 插件的步骤，希望能对你有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值