RabbitMQ初识

最新推荐文章于 2024-12-27 17:18:47 发布
最新推荐文章于 2024-12-27 17:18:47 发布
阅读量412 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： mq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_33854869/article/details/77775232
本文介绍了RabbitMQ的基本概念，包括其解决的问题、架构、核心要素如Exchange、Binding和Queue。还涵盖了RabbitMQ的安装步骤，并简单介绍了Direct、Topic和Fanout等消息路由类型。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

概述   

        RabbitMQ入门到精通,作为RabbitMQ入门是一个很好的范例.

        RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue ）的开源实现,是一种应用程序对应用程序的通信方法.应用程序通过读写出入队列的消息（针对应用程序的数据）来通信,而无需专用连接来链接它们.目前类似于RabbitMQ的消息中间件有很多, RabbitMq、ActiveMq、ZeroMq、kafka都是可选择,RabbitMQ解决的问题

  • 信息的发送者和接收者如何维持这个连接，如果一方的连接中断，这期间的数据如何方式丢失
  • 如何降低发送者和接收者的耦合度
  • 如何让Priority高的接收者先接到数据
  • 如何做到load balance？有效均衡接收者的负载
  • 如何有效的将数据发送到相关的接收者？也就是说将接收者subscribe 不同的数据，如何做有效的filter
  • 如何做到可扩展，甚至将这个通信模块发到cluster上
  • 如何保证接收者接收到了完整，正确的数据

RabbitMQ基本概念

架构


        名词解释:
  • RabbitMQ Server: RabbitMQ 服务核心,是一种投递服务,在应用程序(生成者)与服务器(消费者)之间扮演着路由器的角色,接收生成者消息,同时将消费者路由至消费者
  • ClientA&B:生成者,生成消息,消息的构成:有效载荷payload(数据的载体),标签label(描述payload,包含消费者相关信息)
  • Client1&2&3:消费者,消费消息(注:消息到达消费者时,其label已经清空,也就是消费者不能识别消息来自何处)
        RabbitMQ server 构成
  • Connection:TCP连接.生成者与消费者通过TCP与RabbitMQ连接
  • Channel:信道,虚拟连接,一个Connection下可建立无数Channel,消息在Channel中进行传输(Channel节约通信开销,提高性能,Connection比喻成电缆,Channel就是独立光纤)
  • Exchange&Binding&Queue:交换,绑定,队列.AMQP的三大构成要素.生产者把消息发布到交换器上,消息最终到达队列,并被消费者接收,绑定决定了消息如何从路由器路由到特定的队列.交换器分
  • vhost:一个vhost对应一个独立的RabbitMQ Server,实现逻辑上的分离,互相干扰
         概念补充:
Exchange
       一个消息的传递
  • 生成者发布Messgae至Exchange,指定RootingKey(或者为空串),同时绑定Queue(也绑定RootingKey 与Message 中的RootingKey匹配)--queue需提前申明创建
  • 消费者读取Queue中Message进行消费(1.进行消息确认,消息从Queue中删除2.转发,消息转移至下一个消费者3.拒绝,消息删除或转发)
       Exchange 有三种类型:direct, fanout,topic,还有一种header
  • Direct : 直连,通过RoutingKey匹配Queue
  • Fanout:广播,忽略RoutingKey匹配,发送至所有Queue
  • Topic:规则匹配.按照一定的规则匹配RoutingKey
  • header:用键值对取代RootingKey进行匹配
       安装好的RabbitMQ有几个默认Exchange(好像是8个)

RabbitMQ安装

        window下安装RabbitMQ
  • 下载Erlang,安装(exe直接安装,zip安装需要配系统变量ERLANG_HOME)
  • 下载RabbitMQ.下一步安装...
  • 激活RabbitMQ管理插件,cmd 执行"C:\Program Files\RabbitMQ Server\rabbitmq_server-3.6.6\sbin\rabbitmq-plugins.bat" enable rabbitmq_management
  • 重启RabbitMQ cmd执行net stop RabbitMQ && net start RabbitMQ
  • 访问http://localhost:15672 使用guest/guest(guest账户在localhost下具有所有权限)登录进入ui界面

RabbitMQ基本使用

       为方便测试使用ui创建一个全权限账户zl/123(也可以使用 RabbitMQ 命令)

Direct

package producerAndconsume;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

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

/**
 * Hello world!
 *
 */
public class DirectMQ 
{  
    //交换器名称  
    public  final static String EXCHANGE_NAME = "test.amq.direct";  
    //队列名称  
    public  final static String QUEUE_NAME = "test.queue";  
    
    //RoutingKey  
    public  final static String ROUTINGKEY = "test.routingkey";  
    
    public static ConnectionFactory factory;
    
    public static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
    static {
        /** 
         * 创建连接连接到MabbitMQ 
         */  
        factory = new ConnectionFactory();  
        //设置MabbitMQ所在主机ip或者主机名  
        factory.setHost("localhost"); 
        //指定用户 密码  
        factory.setUsername("zl");  
        factory.setPassword("123");  
        //指定端口  
        factory.setPort(AMQP.PROTOCOL.PORT); 
    }
    
    public static void init() throws Exception{
    	//创建一个连接  
        Connection connection = factory.newConnection(); 
        //创建一信道  
        Channel channel = connection.createChannel();  
        //指定一个队列  
        boolean durable = false; //设置消息持久化  RabbitMQ不允许使用不同的参数重新定义一个队列，所以已经存在的队列，我们无法修改其属性。
        
        //申明一个exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "direct", durable);
        
		/* queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,Map<String, Object> arguments)     
		 * queue:队列名称
		 * durable:持久化(重启不丢失消息)
		 * exclusive:排他性,指针对此connection可见
		 * autoDelete:不使用时自动删除
		 * arguments:其他参数
		 */
        channel.queueDeclare(QUEUE_NAME, durable, false, false, null);  
        channel.close();
        connection.close();
    }
    
    public static void main(String[] argv) throws Exception {
    	init();
    	//生产者要比消费者先启动
    	new Thread(new  Runnable() {
			public void run() {
				try {
					comsume();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}).start();
    	
    	TimeUnit.SECONDS.sleep(1);
    	
        produce();
        
/*    
 * 	   result print
 *     2017-09-04 20:45:09 send message: hello world!
       2017-09-04 20:45:09 Received Message：'hello world!'
        
        */
    }  
    
    public static void comsume() throws Exception {
        Connection connection = factory.newConnection(); 
        Channel channel = connection.createChannel();  
        
        //绑定queue
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME, ROUTINGKEY);
          
        //创建队列消费者  
        QueueingConsumer consumer = new QueueingConsumer(channel);  
        //指定消费队列  
        boolean ack = false ; //打开应答机制   
        // 指定消费队列    
        channel.basicConsume(QUEUE_NAME, ack, consumer);    
          
        //设置最大服务转发消息数量    只有在消费者空闲的时候会发送下一条信息。 (即该消费者处理的最大吞吐量) 
        int prefetchCount = 10;  
        channel.basicQos(prefetchCount);  
          
        while (true)    
        {    
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();    
            String message = new String(delivery.getBody());    
            System.out.println(sf.format(new Date())+" Received Message：'" + message + "'");    
            //发送应答    
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),true);    
        }    
    
    }
    
    public static void produce()  throws Exception{
        Connection connection = factory.newConnection(); 
        Channel channel = connection.createChannel();  	  

       //发送的消息  
        String message = "hello world!";  
        channel.basicPublish(EXCHANGE_NAME, ROUTINGKEY, null, message.getBytes());    
        
        System.out.println(sf.format(new Date())+" send message: "+ message);
        //关闭连接与信道
        channel.close();  
        connection.close();  
    }
}

Topic

package producerAndconsume;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

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

/**
 * Hello world!
 *
 */
public class TopicMQ 
{  
    //交换器名称  
    public  final static String EXCHANGE_NAME = "test.amq.topic";  
    //队列名称 1
    public  final static String QUEUE_NAME = "test.queue";  
    
    //RoutingKey one  
    public  final static String TOPIC_ROUTINGKEY_ONE = "test.routingkey.one";  
    //RoutingKey one  
    public  final static String TOPIC_ROUTINGKEY_TWO = "test.routingkey.two";  
    
    public static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
    public static ConnectionFactory factory;
    
    static {
        /** 
         * 创建连接连接到MabbitMQ 
         */  
        factory = new ConnectionFactory();  
        //设置MabbitMQ所在主机ip或者主机名  
        factory.setHost("localhost"); 
        //指定用户 密码  
        factory.setUsername("zl");  
        factory.setPassword("123");  
        //指定端口  
        factory.setPort(AMQP.PROTOCOL.PORT); 
    }
    
    public static void init() throws Exception{
    	//创建一个连接  
        Connection connection = factory.newConnection(); 
        //创建一信道  
        Channel channel = connection.createChannel();  
        //指定一个队列  
        boolean durable = false; //设置消息持久化  RabbitMQ不允许使用不同的参数重新定义一个队列，所以已经存在的队列，我们无法修改其属性。
        
        //申明一个exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "topic", durable);
        
		/* queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,Map<String, Object> arguments)     
		 * queue:队列名称
		 * durable:持久化(重启不丢失消息)
		 * exclusive:排他性,指针对此connection可见
		 * autoDelete:不使用时自动删除
		 * arguments:其他参数
		 */
        channel.queueDeclare(QUEUE_NAME, durable, false, false, null);  
        channel.close();
        connection.close();
    }
    
    public static void main(String[] argv) throws Exception {
    	init();
    	//生产者要比消费者先启动
    	new Thread(new  Runnable() {
			public void run() {
				try {
					comsume();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}).start();
    	
    	
    	TimeUnit.SECONDS.sleep(1);
    	
        produce(TOPIC_ROUTINGKEY_ONE);
        produce(TOPIC_ROUTINGKEY_TWO);
        
	/*      
	        result print
		2017-09-04 20:46:52 send message: test.routingkey.one
		2017-09-04 20:46:52 Received Message：'test.routingkey.one'
		2017-09-04 20:46:52 send message: test.routingkey.two
		2017-09-04 20:46:52 Received Message：'test.routingkey.two'
	        
	        *
	        */
        
    }  
    
    public static void comsume() throws Exception {
        Connection connection = factory.newConnection(); 
        Channel channel = connection.createChannel();  
        
/*       routingkey匹配规则
        *可以匹配一个标识符。
        #可以匹配0个或多个标识符。*/
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME, "test.routingkey.*");
          
        //创建队列消费者  
        QueueingConsumer consumer = new QueueingConsumer(channel);  
        //指定消费队列  
        boolean ack = false ; //打开应答机制   
        // 指定消费队列    
        channel.basicConsume(QUEUE_NAME, ack, consumer);    
          
        //设置最大服务转发消息数量    只有在消费者空闲的时候会发送下一条信息。 (即该消费者处理的最大吞吐量) 
        int prefetchCount = 10;  
        channel.basicQos(prefetchCount);  
          
        while (true)    
        {    
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();    
            String message = new String(delivery.getBody());    
            System.out.println(sf.format(new Date()) +" Received Message：'" + message + "'");    
            //发送应答    
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),true);    
        }    
    
    }
    
    public static void produce(String routingkey)  throws Exception{
        Connection connection = factory.newConnection(); 
        Channel channel = connection.createChannel();  	  

       //发送的消息  
        String message = routingkey;  
        channel.basicPublish(EXCHANGE_NAME, routingkey, null, message.getBytes());    
        
        System.out.println(sf.format(new Date()) +" send message: "+ message);
        //关闭连接与信道
        channel.close();  
        connection.close();  
    }
}

fanout

package producerAndconsume;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

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

/**
 * Hello world!
 *
 */
public class FanoutMQ 
{  
    //交换器名称  
    public  final static String EXCHANGE_NAME = "test.amq.fanout";  
    
    public static ConnectionFactory factory;
    
    public static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
    static {
        /** 
         * 创建连接连接到MabbitMQ 
         */  
        factory = new ConnectionFactory();  
        //设置MabbitMQ所在主机ip或者主机名  
        factory.setHost("localhost"); 
        //指定用户 密码  
        factory.setUsername("zl");  
        factory.setPassword("123");  
        //指定端口  
        factory.setPort(AMQP.PROTOCOL.PORT); 
    }
    
    public static void init() throws Exception{
    	//创建一个连接  
        Connection connection = factory.newConnection(); 
        //创建一信道  
        Channel channel = connection.createChannel();  
        //指定一个队列  
        boolean durable = false; //设置消息持久化  RabbitMQ不允许使用不同的参数重新定义一个队列，所以已经存在的队列，我们无法修改其属性。
        
        //申明一个exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout", durable);
        
        channel.close();
        connection.close();
    }
    
    public static void main(String[] argv) throws Exception {
    	init();
    	//生产者要比消费者先启动
    	new Thread(new  Runnable() {
			public void run() {
				try {
					comsume();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}).start();
    	
    	TimeUnit.SECONDS.sleep(1);
    	
        produce();
        
/*    
 * 	   result print
		2017-09-04 21:03:16 send message: hello world!
		2017-09-04 21:03:16 amq.gen-y1Apmus-2O0LGRUi8Du_NA Received Message：'hello world!'
        */
    }  
    
    public static void comsume() throws Exception {
        Connection connection = factory.newConnection(); 
        Channel channel = connection.createChannel();  
        
        // 创建一个非持久的、唯一的且自动删除的队列  
        String queueName = channel.queueDeclare().getQueue();  
        
        channel.queueBind(queueName, EXCHANGE_NAME, "");
        //创建队列消费者  
        QueueingConsumer consumer = new QueueingConsumer(channel);  
        //指定消费队列  
        boolean ack = false ; //打开应答机制   
        
        // 指定消费队列
        channel.basicConsume(queueName, ack, consumer);    
          
        //设置最大服务转发消息数量    只有在消费者空闲的时候会发送下一条信息。 (即该消费者处理的最大吞吐量) 
        int prefetchCount = 10;  
        channel.basicQos(prefetchCount);  
          
        while (true)    
        {    
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();    
            String message = new String(delivery.getBody());    
            System.out.println(sf.format(new Date())+" "+ queueName+" Received Message：'" + message + "'");    
            //发送应答    
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),true);    
        }    
    
    }
    
    public static void produce()  throws Exception{
        Connection connection = factory.newConnection(); 
        Channel channel = connection.createChannel();  	  

       //发送的消息  
        String message = "hello world!";  
        channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());    
        
        System.out.println(sf.format(new Date())+" send message: "+ message);
        //关闭连接与信道
        channel.close();  
        connection.close();  
    }
}

RPC

package producerAndconsume;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class RpcMQ 

{  
	private static final String RPC_QUEUE_NAME = "rpc_queue";  
    public static ConnectionFactory factory;
    
    public static SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    
    static {
        /** 
         * 创建连接连接到MabbitMQ 
         */  
        factory = new ConnectionFactory();  
        //设置MabbitMQ所在主机ip或者主机名  
        factory.setHost("localhost"); 
        //指定用户 密码  
        factory.setUsername("zl");  
        factory.setPassword("123");  
        //指定端口  
        factory.setPort(AMQP.PROTOCOL.PORT); 
    }
    
    public static void main(String[] argv) throws Exception {
    	server();
    	
    	for (int i = 0; i < 2; i++) {
    		RPCClient fibonacciRpc =new RpcMQ().new RPCClient();
    		System.out.println(" [x] Requesting check hello "+i);
    		String response = fibonacciRpc.call("hello "+i);
    		System.out.println(" [.] Got '" + response + "'");
    		fibonacciRpc.close();
		}
    	
/*    	 result print
		 [x] Awaiting RPC requests
		 [x] Requesting check hello 0
		 [.] Got 'check 'hello 0' success'
		 [x] Requesting check hello 1
		 [.] Got 'check 'hello 1' success'
    	 */
    	
    }  
    
    public static void server()  throws Exception{
        Connection connection = factory.newConnection();  
        final Channel channel = connection.createChannel();  
        channel.queueDeclare(RPC_QUEUE_NAME, false, false, false, null); 
        
        //可以运行多个服务器进程。通过channel.basicQos设置prefetchCount属性可将负载平均分配到多台服务器上。  
        channel.basicQos(10);  
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                AMQP.BasicProperties replyProps = new AMQP.BasicProperties
                        .Builder()
                        .correlationId(properties.getCorrelationId())
                        .build();
                String response = "";
                try {
                    String message = new String(body,"UTF-8");
                    response += "check '"+message+"' success";
                    System.out.println(sf.format(new Date())+" get message " + message+" and return "+response);
                }
                catch (RuntimeException e){
                    System.out.println("get exception: " + e.toString());
                }
                finally {
                    channel.basicPublish( "", properties.getReplyTo(), replyProps, response.getBytes("UTF-8"));
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        };  
        //打开应答机制autoAck=false  
        channel.basicConsume(RPC_QUEUE_NAME, false, consumer);  
        System.out.println(" [x] Awaiting RPC requests");  
    }
    
    class RPCClient {
    	private Connection connection;
    	private Channel channel;
    	private String replyQueueName;

    	public RPCClient() throws Exception {
    		connection = factory.newConnection();
    		channel = connection.createChannel();
    		// 注册'回调'队列，这样就可以收到RPC响应
    		replyQueueName = channel.queueDeclare().getQueue();
    	}

    	// 发送RPC请求
    	public String call(String message) throws Exception {
    		final String corrId = UUID.randomUUID().toString();

    		AMQP.BasicProperties props = new AMQP.BasicProperties.Builder().correlationId(corrId).replyTo(replyQueueName).build();

    		channel.basicPublish("", RPC_QUEUE_NAME, props, message.getBytes("UTF-8"));

    		final BlockingQueue<String> response = new ArrayBlockingQueue<String>(1);

    		channel.basicConsume(replyQueueName, true, new DefaultConsumer(channel) {
    			@Override
    			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    				if (properties.getCorrelationId().equals(corrId)) {
    					response.offer(new String(body, "UTF-8"));
    				}
    			}
    		});
    		return response.take();
    	}

    	public void close() throws Exception {
    		connection.close();
    	}
    }
}


 

RabbitMQ系列(一)--------安装配置
11-28 2328
RabbitMQ 是通过主机名进行访问的，必须指定能访问的主机名。安装RabbitMQ 前提先要配置好环境 需要先安装Erlang。其中的network是网络配置文件。
RabbitMQ认知篇 - 初识RabbitMQ
The Secret
01-31 741
本文介绍一下RabbitMQ的一些知识点。
【RabbitMQ】RabbitMQ详解
上官玺的博客
09-12 434
RabbitMQ安装详解
RabbitMQ集群搭建及使用(一）
纸上得来终觉浅
05-28 704
RabbitMQ的集群是依赖erlang集群，而erlang集群是通过这个cookie进行通信认证的 首先我们分别在server1,server3上安装erlang sudo apt-get install erlang rabbitmq集群需要通过主机名互相访问 所以必须在这两台机器 /etc/hosts配置以上内容 确保主机名正确 两台机器使用rabbitmq进行通信 使用的安全策略是 erlang.cookie 就是一个随机字符串 两节点必须保持一致 否则 无法添加节点到集群 .
Windows下rabbitmq服务端更新主机名为IP地址和更改端口
weixin_41432198的博客
05-04 1491
Windows设置rabbitmq主机名为IP地址并使用.net 连接rabbitmq
RabbitMq安装过程
shuux666的博客
03-28 3912
安装Erlong RabbitMQ是一个开源的遵循 AMQP协议实现的基于 Erlang语言编写，即需要先安装部署Erlang环境再安装RabbitMQ环境。需加注意的是，根据两者版本号的对应表安装相应版本的Erlang和RabbitMQ。 1.先下载：http://erlang.org/download/otp_src_20.3.tar.gz 2.解压：tar -xvf otp_src_20.3.tar.gz 3.准备环境：yum -y install make gcc gcc-c++ kernel-de
RabbitMQ配置
qq_41860765的博客
02-21 748
保证消息的可靠性需要保证以上过程的可靠性，本项目使用RabbitMQ可以通过如下方面保证消息的可靠性。使用消息队列进行异步通知需要保证消息的可靠性，即生产端将消息成功通知到消费端。mq收到消息进行持久化，当mq重启即使消息没有消费完也不会丢失。重启订单服务，登录rabbitmq，查看交换机自动创建成功。需要配置交换机持久化、队列持久化、发送消息时设置持久化。在订单服务service工程编写MQ配置类，配置交换机。发送消息前使用数据库事务将消息保证到数据库表中。3、消息者收到消息进行处理。
RabbitMq 基础
m0_74825656的博客
12-27 1097
我们观察下，下面这个余额支付功能的流程图：如果我们采用的是基于 OpenFeign 的同步调用，也就是说业务执行流程是这样的：三个步骤依次执行。这其中就存在3个问题：我们目前的业务相对简单，但是随着业务规模扩大，产品的功能也在不断完善。在大多数电商业务中，用户支付成功后都会以短信或者其它方式通知用户，告知支付成功。假如后期产品经理提出这样新的需求，你怎么办？是不是要在上述业务中再加入通知用户的业务？某些电商项目中，还会有积分或金币的概念。假如产品经理提出需求，用户支付成功后，给用户以积分奖励或者返还金币，你
RabbitMQ
b9994的博客
09-21 1611
同步通讯，例打视频，一次只能一人。异步通讯，例发消息，可以多人。现实场景如果用户每次登录都要等待发送消息完成后才结束，性能差。可以把登录信息放入MQ，风控服务去监听，这样大大提高了用户登录的效率。
探索Redis与RabbitMQ：消息队列技术的初识之旅
资源摘要信息: "221208-11MessageQueuing(初识消息队列)" 消息队列(Message Queuing)是一种应用程序之间的通信方法，用于在不同的系统和组件之间进行异步通信。消息队列允许多个系统组件在不需要直接连接的情况下...
RabbitMQ 快速安装与配置
见过水星的博客
05-08 417
Rabbit快速安装与配置 急速入门，在这里我们使用RabbitMQ 3.6.5 版本进行操作： 环境搭建： 官网地址：http://www.rabbitmq.com/ 环境描述：Linux（centos7 Redhat7） 1. 首先在Linux上进行一些软件的准备工作，yum下来一些基础的软件包 yum install build-essential openssl ope...
RabbitMQ服务主机名更改导致消息队列无法连接
热门推荐
Boycy的专栏
03-29 1万+
RabbitMQ服务主机名更改导致消息队列无法连接 在多节点环境中，RabbitMQ服务使用一个独立节点部署。在此环境下，如果修改了RabbitMQ节点的主机名，则需要更新RabbitMQ用户才能保证服务能够被正确访问。 RabbitMQ节点原主机名为： root@Aloe-Express-20:/etc# cat /etc/hostname Aloe-Express-20
RabbitMQ学习入门笔记
Ydoing的专栏
12-12 924
RabbitMQ是什么？AMQP即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。 RabbitMQ是一个开源的AMQP实现，服务器端用Erl
RabbitMQ（三）HelloWorld入门程序
diweikang的博客
08-02 663
了解了RabbitMQ的基本概念之后我们来写一个简单的入门程序HelloWorld。一个producer发送消息，一个接收者接收消息，并在控制台打印出来。如下图： 发送端：Send.java 连接到RabbitMQ（此时服务需要启动），发送一条数据，然后退出。 package com.kang.mq; import com.rabbitmq.client.Channel; import...
RabbitMQ系列之【设置RabbitMQ远程ip登录】
aomiano55778的博客
01-19 1079
由于账号guest具有所有的操作权限，并且又是默认账号，出于安全因素的考虑，guest用户只能通过localhost登陆使用，并建议修改guest用户的密码以及新建其他账号管理使用rabbitmq。 这里我们以创建个test帐号，密码123456为例，创建一个账号并支持远程ip访问。 创建账号 rabbitmqctl add_user test 123456 设...
RabbitMQ简单介绍
yuanAndJava的博客
01-25 347
转载自：http://blog.youkuaiyun.com/dandanzmc/article/details/52244529 RabbitMQ在我看来就是AMQP（Advanced Message Queuing Protocol）标准协议的一个实现，至于这个AMQP的标准协议具体是怎么定的，我不太清楚，没有深入的理解。都说RabbitMQ是一个很好的分布式MQ，我想这也是因为RabbitMQ
RabbitMQ学习之：（一）初识、概念及心得
weixin_30681615的博客
12-28 188
因为网上有一篇很好的RMQ的入门帖子http://lostechies.com/derekgreer/tag/rabbitmq/，所以我就不多说了，就说说我目前看了该作者1~5章后，自己的心得。（所以要看懂我写的内容，需要看完那个作者写的1~5章。你可以先跳过这一篇，因为我后面的博文会依次分析该作者的文章的，等分析完1~5章，就可以回过头来看我写的这篇了） 首先，装好RMQ，且激...
RabbitMQ(一) 初识RabbitMQ
盲目的拾荒者的博客
06-04 506
RabbitMQ是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，RabbitMQ是使用Erlang语言来编写的，并且RabbitMQ是基于AMQP协议的。 哪些大厂在用RabbitMQ，为什么 滴滴、美团、头条 开源、性能优秀、稳定性保障 提供可靠性消息投递模式(confim)、返回模式(return) 与SpringAMQP完美结合、API丰富 集群模式丰富，表达式配置，HA模式，镜像队列模型 保证数据不丢失的前提做到高可靠性、可用性 什么是AMQP高级消息队列协议 A
基于VAEMC架构的物联网综合管理平台_支持多协议设备接入_实时数据采集与分析_云端存储与可视化_远程监控与控制_智能预警与决策支持_适用于工业40_智慧城市_智能家居_农业物联.zip
最新发布
08-16
基于VAEMC架构的物联网综合管理平台_支持多协议设备接入_实时数据采集与分析_云端存储与可视化_远程监控与控制_智能预警与决策支持_适用于工业40_智慧城市_智能家居_农业物联.zip
RabbitMQ实战指南
"RabbitMQ Cookbook：由Sigismondo Boschi和Gabriele Santomaggio合著，该书提供了超过70个实用的食谱，旨在帮助读者利用RabbitMQ开发消息传递应用程序，通过大量现实生活中的例子进行教学。" 《RabbitMQ Cookbook...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值