精华内容
下载资源
问答
  • rabiitmq
    千次阅读
    2022-02-10 19:10:24

    Rabbitmq基本概念

    RabbitMQ是一种消息中间件,用于处理来自客户端的异步消息。服务端将要发送的消息放入到队列池中。接收端可以根据RabbitMQ配置的转发机制接收服务端发来的消息。RabbitMQ依据指定的转发规则进行消息的转发、缓冲和持久化操作,主要用在多服务器间或单服务器的子系统间进行通信,是分布式系统标准的配置。


     

    搭建Rabbitmq服务器:

    rabbitmq安装

    1.使用docker环境,下载rabbitmq:management镜像

    有压缩包的直接使用即可

    docker pull rabbitmq:management

    将压缩包放入root目录下并进行导入镜像:

    docker load -i rabbit-image.gz   #导入rabbit镜像

    docker images   #查看 

    2.关闭防火墙

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

    3.配置管理员用户名和密码

    mkdir /etc/rabbitmq
    vim /etc/rabbitmq/rabbitmq.conf
    
    # 添加两行配置:
    default_user = admin
    default_pass = admin
    

    4.启动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 六中工作模式 在idea中应用

    添加依赖

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

    简单模式:只有一个消费者

    生产者发送消息:

    package rabbitmq.simple;
    
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    public class Test1 {
    	public static void main(String[] args) throws Exception {
    		//创建连接工厂,并设置连接信息
    		ConnectionFactory f = new ConnectionFactory();
    		f.setHost("192.168.64.141");
    		f.setPort(5672);//可选,5672是默认端口
    		f.setUsername("admin");
    		f.setPassword("admin");
    
    		/*
    		 * 与rabbitmq服务器建立连接,
    		 * rabbitmq服务器端使用的是nio,会复用tcp连接,
    		 * 并开辟多个信道与客户端通信
    		 * 以减轻服务器端建立连接的开销
    		 */
    		Connection c = f.newConnection();
    		//建立信道
    		Channel ch = c.createChannel();
    
    		/*
    		 * 声明队列,会在rabbitmq中创建一个队列
    		 * 如果已经创建过该队列,就不能再使用其他参数来创建
    		 * 
    		 * 参数含义:
    		 *   -queue: 队列名称
    		 *   -durable: 队列持久化,true表示RabbitMQ重启后队列仍存在
    		 *   -exclusive: 排他,true表示限制仅当前连接可用
    		 *   -autoDelete: 当最后一个消费者断开后,是否删除队列
    		 *   -arguments: 其他参数
    		 */
    		ch.queueDeclare("helloworld", false,false,false,null);
    
    		/*
    		 * 发布消息
    		 * 这里把消息向默认交换机发送.
    		 * 默认交换机隐含与所有队列绑定,routing key即为队列名称
    		 * 
    		 * 参数含义:
    		 * 	-exchange: 交换机名称,空串表示默认交换机"(AMQP default)",不能用 null 
    		 * 	-routingKey: 对于默认交换机,路由键就是目标队列名称
    		 * 	-props: 其他参数,例如头信息
    		 * 	-body: 消息内容byte[]数组
    		 */
    		ch.basicPublish("", "helloworld", null, "Hello world!".getBytes());
    
    		System.out.println("消息已发送");
    		c.close();
    	}
    }
    

    消费者接收消息:

     

    package rabbitmq.simple;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    import com.rabbitmq.client.CancelCallback;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    import com.rabbitmq.client.DeliverCallback;
    import com.rabbitmq.client.Delivery;
    
    public class Test2 {
    	public static void main(String[] args) throws Exception {
    		//连接工厂
    		ConnectionFactory f = new ConnectionFactory();
    		f.setHost("192.168.64.141");
    		f.setUsername("admin");
    		f.setPassword("admin");
    		//建立连接
    		Connection c = f.newConnection();
    		//建立信道
    		Channel ch = c.createChannel();
    		//声明队列,如果该队列已经创建过,则不会重复创建
    		ch.queueDeclare("helloworld",false,false,false,null);
    		System.out.println("等待接收数据");
    		
    		//收到消息后用来处理消息的回调对象
    		DeliverCallback callback = new DeliverCallback() {
    			@Override
    			public void handle(String consumerTag, Delivery message) throws IOException {
    				String msg = new String(message.getBody(), "UTF-8");
    				System.out.println("收到: "+msg);
    			}
    		};
    		
    		//消费者取消时的回调对象
    		CancelCallback cancel = new CancelCallback() {
    			@Override
    			public void handle(String consumerTag) throws IOException {
    			}
    		};
    		
    		ch.basicConsume("helloworld", true, callback, cancel);
    	}
    }
    

    FANOUT群发模式

    生产者发送消息时会发送给每一个接收者

    生产者:

    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.141");    //进行连接对应服务的ip
            f.setPort(5672);                //访问的消息服务的端口号
            f.setUsername("admin");         //账号密码
            f.setPassword("admin");
    
            Connection connection = f.newConnection();
            Channel c = connection.createChannel();     //通信通道
            //创建Fanout交换机: logs为消息队列的名字   发布和订阅模式 群发机制
            c.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
    
            while (true){
                System.out.println("输入传递的信息:");
                String s = new Scanner(System.in).nextLine();
                c.basicPublish("logs","",null,s.getBytes());
            }
    
        }
    }
    

    消费者:

    import com.rabbitmq.client.*;
    
    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.141");    //进行连接对应服务的ip
            f.setPort(5672);                //访问的消息服务的端口号
            f.setUsername("admin");         //账号密码
            f.setPassword("admin");
    
            Connection connection = f.newConnection();
            Channel c = connection.createChannel();     //通信通道
    
            //1.创建队列 2.创建交换机 3.进行消息队列的绑定
            String queue = UUID.randomUUID().toString();//创建随机队列 保存得到的消息
                        //队列名     非持久     独占     自动删除
            c.queueDeclare(queue,false,true,true,null);
            //创建交换机  生产者是什么消息模式就创造什么消息模式  fanout交换机
            c.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
            //进行绑定  对fanout交换机来说 第三个参数是无效的
            c.queueBind(queue,"logs","");
    
            //正常接收消息 创建回调对象
            DeliverCallback deliverCallback =(consumerTag,message) -> {
    
                //此处处理消息
                String s = new String(message.getBody());
                System.out.println("收到:"+s);
            };
            CancelCallback cancelCallback =consumerTag -> {
            };
            //开始接受消息,把消息传递给一个回调对象进行处理
            c.basicConsume(queue,true,deliverCallback,cancelCallback);
    
        }
    
    }
    

     路由模式  Direct

    路由模式,设定关键词,会根据生产者发送的关键词进行接收消息。如果关键词不匹配是不会接收消息的。

    生产者:

    import java.io.IOException;
    import java.util.Scanner;
    import java.util.concurrent.TimeoutException;
    
    public class Producer1 {
    
        public static void main(String[] args) throws IOException, TimeoutException {
    //当你生产者有一个队列时,消费者也必须一个队列进行接收。
    //通过交换机进行发送消息,可以定义消息是否持久。交换机不存储消息需要队列接收消息
    
            ConnectionFactory f = new ConnectionFactory();  //通过连接工厂进行连接
            f.setHost("192.168.64.141");    //进行连接对应服务的ip
            f.setPort(5672);                //访问的消息服务的端口号
            f.setUsername("admin");         //账号密码
            f.setPassword("admin");
    
            Connection connection = f.newConnection();
            Channel c = connection.createChannel();     //通信通道
    
            //创建路由模式交换机 : Direct
            c.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();
                //对默认交换机“”,会自动使用队列名作为路由键
                c.basicPublish("direct_logs",k,null,s.getBytes());
            }
    
    
        }
    }
    

     消费者:

    
    import com.rabbitmq.client.*;
    import java.io.IOException;
    import java.util.Scanner;
    import java.util.UUID;
    import java.util.concurrent.TimeoutException;
    
    public class Consumer1 {
        public static void main(String[] args) throws IOException, TimeoutException {
    
            ConnectionFactory f = new ConnectionFactory();  //通过连接工厂进行连接
            f.setHost("192.168.64.141");    //进行连接对应服务的ip
            f.setPort(5672);                //访问的消息服务的端口号
            f.setUsername("admin");         //账号密码
            f.setPassword("admin");
    
            Connection connection = f.newConnection();
            Channel c = connection.createChannel();     //通信通道
    
            //1.创建队列 2.创建交换机 3.进行消息队列的绑定
            String queue = UUID.randomUUID().toString();//创建随机队列 保存得到的消息
                        //队列名     非持久     独占     自动删除
            c.queueDeclare(queue,false,true,true,null);
            c.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);//创建路由交换机
            System.out.println("输入绑定的关键词,用空格隔开");
            String s = new Scanner(System.in).nextLine();
            String[] a = s.split("\\s+");  //  \s是空白格 + 指一到多个
            for (String k : a){
                c.queueBind(queue,"direct_logs",k);  //进行遍历绑定
            }
            //从队列接收消息
            DeliverCallback deliverCallback =(consumerTag, message) -> {
    
                //此处处理消息
                String msg = new String(message.getBody());
                String key = message.getEnvelope().getRoutingKey();//得到路由键
                System.out.println(key+"----"+msg);
            };
            CancelCallback cancelCallback =consumerTag -> {
            };
            //开始接受消息,把消息传递给一个回调对象进行处理
            c.basicConsume(queue,true,deliverCallback,cancelCallback);
    
        }
    }

     主题模式:

    发送到Topic交换机的消息,它的的routingKey,必须是由点分隔的多个单词。单词可以是任何东西,但通常是与消息相关的一些特性。几个有效的routingKey示例:“stock.usd.nyse”、“nyse.vmw”、“quick.orange.rabbit”。routingKey可以有任意多的单词,最多255个字节。

    bindingKey也必须采用相同的形式。Topic交换机的逻辑与直连交换机类似——使用特定routingKey发送的消息将被传递到所有使用匹配bindingKey绑定的队列。bindingKey有两个重要的特殊点:

    * 可以通配单个单词。
    # 可以通配零个或多个单词

    生产者:

    public class Producer5 {
        public static void main(String[] args) throws IOException, TimeoutException {
            //生产者创建交换机   消费者创建队列
            //连接
    
            //连接
            ConnectionFactory f = new ConnectionFactory();//连接工厂
            f.setHost("192.168.64.129"); //进行连接对应服务的ip
            f.setPort(5672);            //访问的消息服务端口号
            f.setUsername("admin");     //账号
            f.setPassword("admin");    //密码
            Connection con = f.newConnection();
            Channel c = con.createChannel();//通信通道
    
            //创建Topic交换机 :topic_logs    会自动使用队列作为关键词
            c.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();
                //对默认交换机“”,会自动使用队列名作为路由键
                c.basicPublish("topic_logs", k, null, s.getBytes());
    
            }
    
        }
    }

    消费者:

    public class Consumer5 {
        public static void main(String[] args) throws IOException, TimeoutException {
    
            //连接
            ConnectionFactory f = new ConnectionFactory();//连接工厂
            f.setHost("192.168.64.141"); //进行连接对应服务的ip
            f.setPort(5672);            //访问的消息服务端口号
            f.setUsername("admin");     //账号
            f.setPassword("admin");    //密码
            Connection con = f.newConnection();
            Channel c = con.createChannel();//通信通道
    
            //1.创建随机队列  2.创建交换机 3.使用绑定建关键词绑定
            String queue = UUID.randomUUID().toString();
            //非持久,独占,自动删除
            c.queueDeclare(queue, false, true, true, null);
            c.exchangeDeclare("topic_logs", BuiltinExchangeType.TOPIC);//创建交换机
            System.out.println("输入绑定建关键词,用空格隔开:");
            String s = new Scanner(System.in).nextLine();
            String[] a = s.split("\\s+");  //   \s是空白字符  + 指一到多个
            for (String k : a) {
                c.queueBind(queue, "topic_logs", k);  //进行循环遍历绑定
            }
    
            //正常接收消息
            //正常从队列接收消息
            DeliverCallback deliverCallback = (consumerTag, message) -> {
                //此处处理消息
                String msg = new String(message.getBody());
                String key = message.getEnvelope().getRoutingKey();//得到路由键
                System.out.println(key + "---" + msg);
            };
            CancelCallback cancelCallback = consumerTag -> {
            };
            c.basicConsume(queue, true, deliverCallback, cancelCallback);
    
        }
    }
    

     队列的持久化,消息持久化

    将创建的队列第二个false改成true即可变成持久操作。

    已经创建的队列参数是不能修改的,因为已经上传到服务器中了,可以创建一个新的队列再进行修改后面的参数。生产者与消费者必须一直。

    更多相关内容
  • rabbitmq-server-3.9.11.exe
  • rabbitmq3.6.x延迟队列插件下载
  • RabbitMQ封装为c++版本,并且使用方式为发布订阅模式
  • 封装了RabbitMQ的订阅者线程和发布者线程(还有个初始化工厂的连接工具类),另外附加一个安卓的使用demo
  • RabbitMQ笔记.pdf

    2019-09-15 20:26:11
    RabbitMQ的学习笔记,记录了消息中间件的相关知识点和RabbitMQ基础操作
  • rabbitMQ_Windows版.zip

    2020-05-07 15:20:40
    rabbitMQ_Windows版附带安装说明
  • rabbitmq 测试工具

    2019-02-16 09:32:02
    rabbitmq 测试工具
  • rabbitmq-server-3.8.1.rar

    2019-11-17 16:38:37
    RabbitMQ消息队列下载安装(Windows版本)RabbitMQ消息队列下载安装(Windows版本) rabbitmq-server-3.8.1.exe
  • RabbitMq客户端Dll

    2018-07-30 22:49:20
    这是RabbitMq客户端的Dll RabbitMQ.Client.dll 用于c# Unity 都行 对应的使用方法 https://blog.csdn.net/ljason1993/article/details/81292993
  • RabbitMQ技术帮助文档

    2018-09-19 23:44:19
    RabbitMQ技术帮助文档
  • rabbitMQ课件.zip

    2021-10-26 21:00:46
    01RabbitMQ入门篇 02RabbitMQ与Spring_SpringBoot整合 03RabbitMQ高级特性 RabbitMQ安装说明 RabbitMQ集群搭建
  • RabbitMQ测试工具

    2018-04-10 10:51:35
    RabbitMQ测试工具,RaabitMQ,用WPF自己写了一个RabbitMQ的调试工具
  • rabbitmq.conf

    2021-03-05 12:54:26
    RabbitMQ配置文件模板
  • rabbitmq-server-3.7.14.zip

    2019-05-19 21:53:52
    最新稳定版 rabbitmq 安装包。rabbitmq = 消息+异步+消息队列
  • 【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题【BAT必备】rabbitMq面试题...
  • 这资料适用于学习,希望对大家的学习有点帮助。
  • rabbitmq安装步骤

    2018-07-11 16:40:23
    rabbitmq安装步骤以及简单的操作命令........
  • C#的Demo项目:RabbitMQ封装和使用

    热门讨论 2018-05-23 09:43:00
    如题,C#的Demo项目:RabbitMQ封装和使用, 引用了RabbitMQ.Client 版本:3.6.9 RabbitMQ .NET客户端操作类库, 并简单展示了3种Exchange的使用
  • RabbitMQ.md

    2020-09-02 15:05:35
    RabbitMQ学习笔记 RabbitMQ学习笔记 RabbitMQ学习笔记 RabbitMQ学习笔记 RabbitMQ学习笔记 RabbitMQ学习笔记
  • 《深入RabbitMQ》.pdf.zip

    2019-07-23 16:55:37
    深入RabbitMq,适合深入研究使用RabbitMq技术,非常实用
  • rabbitmq 所需jar包

    2018-03-27 14:05:08
    rabbitmq,amqp-client,spring-amqp,spring-rabbit,spring-retry JAR包合集
  • Linux下安装RabbitMQ

    2017-08-18 12:23:04
    rabbitmq3.6版本为例
  • rabbitmq.config

    2019-08-04 17:36:35
    rabbitmq配置文件,rabbitmq配置文件,rabbitmq配置文件,rabbitmq配置文件,rabbitmq配置文件,rabbitmq配置文件,rabbitmq配置文件
  • rabbitmq-server.3.6.6.exe
  • RabbitMQ入门 -- 阿里云服务器安装RabbitMQ

    千次阅读 多人点赞 2022-05-16 13:17:20
    RabbitMQ是什么,浅谈RabbitMQ

    📢📢📢📣📣📣

    哈喽!大家好,我是【Bug 终结者,【CSDNJava领域优质创作者】🏆,阿里云专家博主🏆,51CTO人气博主🏆,InfoQ写作专家🏆

    一位上进心十足,拥有极强学习力的【Java领域博主】😜😜😜

    🏅【Bug 终结者】博客的领域是【面向后端技术】的学习,未来会持续更新更多的【后端技术】以及【学习心得】。 偶尔会分享些前端基础知识,会更新实战项目,面向企业级开发应用
    🏅 如果有对【后端技术】、【前端领域】感兴趣的【小可爱】,欢迎关注【Bug 终结者】💞💞💞


    ❤️❤️❤️ 感谢各位大可爱小可爱! ❤️❤️❤️

    在这里插入图片描述

    一、什么是MQ?

    消息队列(Message Queue,简称MQ),从字面意思上看,本质是个队列,FIFO先入先出,只不过队列中存放的内容是message而已。

    其主要用途:不同进程Process/线程Thread之间通信。

    队列是一种先进先出的结构:FIFO

    把要传输的数据放在队列中

    把数据放到消息队列叫生产者

    从消息队列取出消息叫做消费者

    二、什么是RabbitMQ?

    RabbitMQ是一套开源(MPL)的消息队列服务软件,是由 LShift 提供的一个 Advanced Message Queuing Protocol (AMQP) 的开源实现,由以高性能、健壮以及可伸缩性出名的 Erlang 写成。

    RabbitMQ的特性

    • 可伸缩性:集群服务
    • 消息持久化:从内存持久化消息到硬盘,再从硬盘加载到内存

    三、使用RabbitMQ的好处

    ☁️解耦

    系统A在代码中直接调用系统B和系统C的代码,如果将来D系统接入,系统A还需要修改代码,过于麻烦!

    系统A可以生成一个id,然后系统B需要这个id,系统A去调用了系统B

    过了段时间,系统C说也要系统A的id,那么这时接触系统B的引用,去讲id传给系统C

    这时又来了系统D,系统D也要系统A的id,系统A又解除了系统C,去调用了系统D,反反复复,很麻烦

    系统A的负责人觉得改来改去太麻烦了,没意思,跑路了。

    过段时间,公司来了位大佬,大佬说将系统A的id,存入消息队列,谁需要谁去拿,这样系统A就不用来回改动了,完美解决了参数调用问题!

    系统A不关心谁去调用id,只负责生产数据并存入消息队列,其它系统即使挂了或请求超时,也跟系统A没有任何关系

    这样就实现了系统A、B、C、D之间的解耦!

    ⛄异步

    再来看看这种情况,系统A还是直接调用系统B、C、D

    系统A:主要业务

    系统B:短信业务

    系统C:邮箱业务

    系统D:处理后续业务

    系统A下单成功后会去调用系统B,但是如果一个一个的调用,会大大的降低效率,假设每个业务执行时间100ms,那么4个业务执行完毕就是400ms,这种就被称为阻塞执行

    那么我们的消息队列采用了异步机制,当我们下单完成后,会去异步的调用其它业务,会极大的降低系统的执行时间,提升效率!

    ⚡削峰/限流

    例如:双十一大促销,这时的流量是很大很大的,并发很高,比如每秒5000个请求,假设现在又3台机器处理,并且每台机器每秒只能处理1500次请求,那么多出来的请求500请求,会将系统搞垮的,这时我们可以将多出来的请求放入消息队列中

    这样即使每秒有10000个请求,也不会将系统搞垮,会在消息队列中等待,由系统去分配请求处理

    四、Linux环境下手动安装RabbitMQ

    🚡环境准备

    阿里云Centos7.6服务器

    lsb_release -a
    

    在这里插入图片描述

    在2022年5月,RabbitMQ官方发布推文宣称最新的版本已经不支持Centos7.x系列,但是我们可以通过下载之前支持的版本来部署!

    下载RabbitMQ RPM包

    RabbitMQ下载

    在这里插入图片描述

    下载成功如下

    在这里插入图片描述

    下载ErLang RPM包

    这里需要注意,下载的版本要和RabbitMQ对应,必须支持下载的ErLang版本

    在这里插入图片描述

    我们找到下载的是 3.8.13 ,支持的最低是 22.3 最高是 23.x

    下载ErLange

    在这里插入图片描述

    点击Download下载或单机wget复制下在Linux下 下载

    使用FileZilla上传至阿里云服务器

    阿里云服务器在 /usr/local 下新建 rabbitmq 文件夹

    在这里插入图片描述

    上传完成

    安装ErLang

    # 解压erlang文件
    rpm -Uvh erlang-23.2.7-2.el7.x86_64.rpm
    #安装erlang
    yum install -y erlang
    

    在这里插入图片描述

    查看erlang版本

    erl -v
    

    在这里插入图片描述

    ♻️安装并启动RabbitMQ

    在安装RabbitMQ之前要安装一个插件

    yum install -y socat
    

    在这里插入图片描述

    解压并安装RabbitMQ

    # 解压
    rpm -Uvh rabbitmq-server-3.8.13-1.el8.noarch.rpm
    # 安装
    yum install -y rabbitmq-server
    

    在这里插入图片描述

    启动RabbitMQ服务

    # 启动服务
    systemctl start rabbitmq-server
    # 查看当前的运行状态
    systemctl status rabbitmq-server
    # 重启服务
    systemctl restart rabbitmq-server
    # 停止服务
    systemctl stop rabbitmq-server
    

    在这里插入图片描述

    可以看到,启动成功!

    五、手动安装RabbitMQWeb管理界面和授权

    ⌛安装并启动RabbitMQ管理插件

    # 安装RabbitMQWeb管理插件
    rabbitmq-plugins enable rabbitmq_management
    # 安装完成后重启rabbitmq服务
    systemctl restart rabbitmq-server
    

    在这里插入图片描述

    启动成功,默认Web页面占用端口为 15672,我们去阿里云服务器控制台开放此端口

    在这里插入图片描述

    测试访问

    浏览器输入 http://您的ip地址:15672

    出现如下界面

    在这里插入图片描述

    默认登录账号密码 guest guest 登录测试
    在这里插入图片描述

    这个意思是我们只能通过本地来登录guest 账户

    下面给出解决方案

    😃添加账户

    # 添加一个用户
    rabbitmqctl add_user admin admin
    # 将用户设置为admin权限
    rabbitmqctl set_user_tags admin administrator
    

    在这里插入图片描述

    ✳️再次测试访问

    在这里插入图片描述

    访问成功,手动安装成功!

    六、Linux环境下Docker安装RabbitMQ

    ⌛安装Docker

    先查看本机是否存在Docker,删除旧版本Docker

    查看docker 版本

    docker version
    

    在这里插入图片描述

    没有docker,我们执行以下命令,删除残余文件

    yum remove docker \
                   docker-client \
                   docker-client-latest \
                   docker-common \
                   docker-latest \
                   docker-latest-logrotate \
                   docker-logrotate \
                   docker-engine
    
    

    进入Linux根目录,安装Docker

    # 安装yum-utils包(提供yum-config-manager 实用程序)并设置稳定的存储库。
    yum install -y yum-utils
    
    # 安装阿里云配置
    yum-config-manager \
         --add-repo \
         http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    

    安装Docker 最新引擎

    yum install docker-ce docker-ce-cli containerd.io
    

    在这里插入图片描述

    输入y确认即可!

    🗳️配置阿里云加速镜像

    打开阿里云控制台,弹性计算 --> 容器与镜像服务

    在这里插入图片描述

    打开之后选择 镜像工具 --> 镜像加速器,复制内容即可
    在这里插入图片描述


    进入Linux服务器根据步骤配置镜像加速器

    # 创建docker文件夹
    sudo mkdir -p /etc/docker
    
    # 打开文件并配置内容
    sudo tee /etc/docker/daemon.json <<-'EOF'
    {
      "registry-mirrors": ["https://pfjide5p.mirror.aliyuncs.com"]
    }
    EOF
    
    # 重启服务
    sudo systemctl daemon-reload
    # 启动docker
    sudo systemctl restart docker
    

    新建文件夹

    在这里插入图片描述

    配置内容,并重启服务

    在这里插入图片描述

    根据步骤一步步创建即可!

    ♨️安装并启动RabbitMQ

    # 获取镜像,这个是带着web页面的
    docker pull rabbitmq:management
    # 运行 rabbitmq 并映射端口 设置默认账户密码admin
    docker run -di --name myrabbit -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin -p 15672:15672 -p 5672:5672 -p 25672:25672 -p 61613:61613 -p 1883:1883 rabbitmq:management
    

    在这里插入图片描述

    ❇️测试RabbitMQ

    浏览器输入 http://您的ip地址:15672 并输入admin admin

    出现如下界面

    在这里插入图片描述

    至此,在Docker内安装RabbitMQ完成!

    ⛵小结

    以上就是【Bug 终结者】对RabbitMQ入门 – 阿里云服务器安装RabbitMQ简单的概述,RabbitMQ是很常用的中间件,使用它,可提高程序的性能,底层使用通道,多路复用等,完美的利用CPU完成任务,RabbitMQ可承受高并发,拥有高性能,可谓是开发利器!

    如果这篇【文章】有帮助到你,希望可以给【Bug 终结者】点个赞👍,创作不易,如果有对【后端技术】、【前端领域】感兴趣的小可爱,也欢迎关注❤️❤️❤️ 【Bug 终结者】❤️❤️❤️,我将会给你带来巨大的【收获与惊喜】💝💝💝!

    展开全文
  • rabbitmq配置文件 rabbitmq.config

    热门讨论 2014-11-04 14:42:06
    rabbitmq配置文件,用于rabbitmq管理
  • 手把手教你搭建 RabbitMQ 集群

    千次阅读 多人点赞 2021-12-12 16:55:00
    单个的 RabbitMQ 肯定无法实现高可用,要想高可用,还得上集群。 今天松哥就来和大家聊一聊 RabbitMQ 集群的搭建。 1. 两种模式 说到集群,小伙伴们可能第一个问题是,如果我有一个 RabbitMQ 集群,那么是不是我的...


    单个的 RabbitMQ 肯定无法实现高可用,要想高可用,还得上集群。

    今天松哥就来和大家聊一聊 RabbitMQ 集群的搭建。

    1. 两种模式

    说到集群,小伙伴们可能第一个问题是,如果我有一个 RabbitMQ 集群,那么是不是我的消息集群中的每一个实例都保存一份呢?

    这其实就涉及到 RabbitMQ 集群的两种模式:

    • 普通集群
    • 镜像集群

    1.1 普通集群

    普通集群模式,就是将 RabbitMQ 部署到多台服务器上,每个服务器启动一个 RabbitMQ 实例,多个实例之间进行消息通信。

    此时我们创建的队列 Queue,它的元数据(主要就是 Queue 的一些配置信息)会在所有的 RabbitMQ 实例中进行同步,但是队列中的消息只会存在于一个 RabbitMQ 实例上,而不会同步到其他队列。

    当我们消费消息的时候,如果连接到了另外一个实例,那么那个实例会通过元数据定位到 Queue 所在的位置,然后访问 Queue 所在的实例,拉取数据过来发送给消费者。

    这种集群可以提高 RabbitMQ 的消息吞吐能力,但是无法保证高可用,因为一旦一个 RabbitMQ 实例挂了,消息就没法访问了,如果消息队列做了持久化,那么等 RabbitMQ 实例恢复后,就可以继续访问了;如果消息队列没做持久化,那么消息就丢了。

    大致的流程图如下图:

    1.2 镜像集群

    它和普通集群最大的区别在于 Queue 数据和原数据不再是单独存储在一台机器上,而是同时存储在多台机器上。也就是说每个 RabbitMQ 实例都有一份镜像数据(副本数据)。每次写入消息的时候都会自动把数据同步到多台实例上去,这样一旦其中一台机器发生故障,其他机器还有一份副本数据可以继续提供服务,也就实现了高可用。

    大致流程图如下图:

    1.3 节点类型

    RabbitMQ 中的节点类型有两种:

    • RAM node:内存节点将所有的队列、交换机、绑定、用户、权限和 vhost 的元数据定义存储在内存中,好处是可以使得交换机和队列声明等操作速度更快。
    • Disk node:将元数据存储在磁盘中,单节点系统只允许磁盘类型的节点,防止重启 RabbitMQ 的时候,丢失系统的配置信息

    RabbitMQ 要求在集群中至少有一个磁盘节点,所有其他节点可以是内存节点,当节点加入或者离开集群时,必须要将该变更通知到至少一个磁盘节点。如果集群中唯一的一个磁盘节点崩溃的话,集群仍然可以保持运行,但是无法进行其他操作(增删改查),直到节点恢复。为了确保集群信息的可靠性,或者在不确定使用磁盘节点还是内存节点的时候,建议直接用磁盘节点。

    2. 搭建普通集群

    2.1 预备知识

    大致的结构了解了,接下来我们就把集群给搭建起来。先从普通集群开始,我们就使用 docker 来搭建。

    搭建之前,有两个预备知识需要大家了解:

    1. 搭建集群时,节点中的 Erlang Cookie 值要一致,默认情况下,文件在 /var/lib/rabbitmq/.erlang.cookie,我们在用 docker 创建 RabbitMQ 容器时,可以为之设置相应的 Cookie 值。
    2. RabbitMQ 是通过主机名来连接服务,必须保证各个主机名之间可以 ping 通。可以通过编辑 /etc/hosts 来手工添加主机名和 IP 对应关系。如果主机名 ping 不通,RabbitMQ 服务启动会失败(如果我们是在不同的服务器上搭建 RabbitMQ 集群,大家需要注意这一点,接下来的 2.2 小结,我们将通过 Docker 的容器连接 link 来实现容器之间的访问,略有不同)。

    2.2 开始搭建

    执行如下命令创建三个 RabbitMQ 容器:

    docker run -d --hostname rabbit01 --name mq01 -p 5671:5672 -p 15671:15672 -e RABBITMQ_ERLANG_COOKIE="javaboy_rabbitmq_cookie" rabbitmq:3-management
    docker run -d --hostname rabbit02 --name mq02 --link mq01:mylink01 -p 5672:5672 -p 15672:15672 -e RABBITMQ_ERLANG_COOKIE="javaboy_rabbitmq_cookie" rabbitmq:3-management
    docker run -d --hostname rabbit03 --name mq03 --link mq01:mylink02 --link mq02:mylink03 -p 5673:5672 -p 15673:15672 -e RABBITMQ_ERLANG_COOKIE="javaboy_rabbitmq_cookie" rabbitmq:3-management
    

    运行结果如下:

    三个节点现在就启动好了,注意在 mq02 和 mq03 中,分别使用了 --link 参数来实现容器连接,关于这个参数,如果大家不懂,可以在公众号江南一点雨后台回复 docker,由松哥写的 docker 入门教程,里边有讲这个。这里我就不啰嗦了。另外还需要注意,mq03 容器中要既能够连接 mq01 也能够连接 mq02。

    接下来进入到 mq02 容器中,首先查看一下 hosts 文件,可以看到我们配置的容器连接已经生效了:

    将来在 mq02 容器中,就可以通过 mylink01 或者 rabbit01 访问到 mq01 容器了。

    接下来我们开始集群的配置。

    分别执行如下命令将 mq02 容器加入集群中:

    rabbitmqctl stop_app
    rabbitmqctl join_cluster rabbit@rabbit01
    rabbitmqctl start_app
    

    接下来输入如下命令我们可以查看集群的状态:

    rabbitmqctl cluster_status
    

    可以看到,集群中已经有两个节点了。

    接下来通过相同的方式将 mq03 也加入到集群中:

    rabbitmqctl stop_app
    rabbitmqctl join_cluster rabbit@rabbit01
    rabbitmqctl start_app
    

    接下来,我们可以查看集群信息:

    可以看到,此时集群中已经有三个节点了。

    其实,这个时候,我们也可以通过网页来查看集群信息,在三个 RabbitMQ 实例的 Web 端首页,都可以看到如下内容:

    2.3 代码测试

    接下来我们来简单测试一下这个集群。

    我们创建一个名为 mq_cluster_demo 的父工程,然后在其中创建两个子工程。

    第一个子工程名为 provider,是一个消息生产者,创建时引入 Web 和 RabbitMQ 依赖,如下:

    然后配置 applicaiton.properties,内容如下(注意集群配置):

    spring.rabbitmq.addresses=localhost:5671,localhost:5672,localhost:5673
    spring.rabbitmq.username=guest
    spring.rabbitmq.password=guest
    

    接下来提供一个简单的队列,如下:

    @Configuration
    public class RabbitConfig {
        public static final String MY_QUEUE_NAME = "my_queue_name";
        public static final String MY_EXCHANGE_NAME = "my_exchange_name";
        public static final String MY_ROUTING_KEY = "my_queue_name";
    
        @Bean
        Queue queue() {
            return new Queue(MY_QUEUE_NAME, true, false, false);
        }
    
        @Bean
        DirectExchange directExchange() {
            return new DirectExchange(MY_EXCHANGE_NAME, true, false);
        }
    
        @Bean
        Binding binding() {
            return BindingBuilder.bind(queue())
                    .to(directExchange())
                    .with(MY_ROUTING_KEY);
        }
    }
    

    这个没啥好说的,都是基本内容,接下来我们在单元测试中进行消息发送测试:

    @SpringBootTest
    class ProviderApplicationTests {
    
        @Autowired
        RabbitTemplate rabbitTemplate;
    
        @Test
        void contextLoads() {
            rabbitTemplate.convertAndSend(null, RabbitConfig.MY_QUEUE_NAME, "hello 江南一点雨");
        }
    
    }
    

    这条消息发送成功之后,在 RabbitMQ 的 Web 管理端,我们会看到三个 RabbitMQ 实例上都会显示有一条消息,但是实际上消息本身只存在于一个 RabbitMQ 实例。

    接下来我们再创建一个消息消费者,消息消费者的依赖以及配置和消息生产者都是一模一样,我就不重复了,消息消费者中增加一个消息接收器:

    @Component
    public class MsgReceiver {
    
        @RabbitListener(queues = RabbitConfig.MY_QUEUE_NAME)
        public void handleMsg(String msg) {
            System.out.println("msg = " + msg);
        }
    }
    

    当消息消费者启动成功后,这个方法中只收到一条消息,进一步验证了我们搭建的 RabbitMQ 集群是没问题的。

    2.4 反向测试

    接下来松哥再举两个反例,以证明消息并没有同步到其他 RabbitMQ 实例。

    确保三个 RabbitMQ 实例都是启动状态,关闭掉 Consumer,然后通过 provider 发送一条消息,发送成功之后,关闭 mq01 实例,然后启动 Consumer 实例,此时 Consumer 实例并不会消费消息,反而会报错说 mq01 实例连接不上,这个例子就可以说明消息在 mq01 上,并没有同步到另外两个 MQ 上。相反,如果 provider 发送消息成功之后,我们没有关闭 mq01 实例而是关闭了 mq02 实例,那么你就会发现消息的消费不受影响。

    3. 搭建镜像集群

    所谓的镜像集群模式并不需要额外搭建,只需要我们将队列配置为镜像队列即可。

    这个配置可以通过网页配置,也可以通过命令行配置,我们分别来看。

    3.1 网页配置镜像队列

    先来看看网页上如何配置镜像队列。

    点击 Admin 选项卡,然后点击右边的 Policies,再点击 Add/update a policy,如下图:

    接下来添加一个策略,如下图:

    各参数含义如下:

    • Name: policy 的名称。
    • Pattern: queue 的匹配模式(正则表达式)。
    • Definition:镜像定义,主要有三个参数:ha-mode, ha-params, ha-sync-mode。
      • ha-mode:指明镜像队列的模式,有效值为 all、exactly、nodes。其中 all 表示在集群中所有的节点上进行镜像(默认即此);exactly 表示在指定个数的节点上进行镜像,节点的个数由 ha-params 指定;nodes 表示在指定的节点上进行镜像,节点名称通过 ha-params 指定。
      • ha-params:ha-mode 模式需要用到的参数。
      • ha-sync-mode:进行队列中消息的同步方式,有效值为 automatic 和 manual。
    • priority 为可选参数,表示 policy 的优先级。

    配置完成后,点击下面的 add/update policy 按钮,完成策略的添加,如下:

    添加完成后,我们可以进行一个简单的测试。

    首先确认三个 RabbitMQ 都启动了,然后用上面的 provider 向消息队列发送一条消息。

    发完之后关闭 mq01 实例。

    接下来启动 consumer,此时发现 consumer 可以完成消息的消费(注意和前面的反向测试区分),这就说明镜像队列已经搭建成功了。

    3.2 命令行配置镜像队列

    命令行的配置格式如下:

    rabbitmqctl set_policy [-p vhost] [--priority priority] [--apply-to apply-to] {name} {pattern} {definition}
    

    举一个简单的配置案例:

    rabbitmqctl set_policy -p / --apply-to queues my_queue_mirror "^" '{"ha-mode":"all","ha-sync-mode":"automatic"}'
    

    4. 小结

    好啦,这就是松哥和大家分享的 RabbitMQ 中的集群搭建,感兴趣的小伙伴赶紧去试试吧~

    展开全文
  • rabbitmq-client.jar

    2016-02-23 15:52:05
    rabbitmq的javaClient库,导入到项目中便可使用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 270,169
精华内容 108,067
关键字:

rabiitmq