RabbitMq 的几种常见模式 (仅供参考)

最新推荐文章于 2022-08-01 22:01:36 发布
最新推荐文章于 2022-08-01 22:01:36 发布
阅读量205 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39205291/article/details/90293797
版权

简单队列 

 即一个生产者和一个消费者

 

public class OneToOne {

	private static final String HOST = "192.168.101.210";
	private static final int PORT = 5672;
	private static final String USERNAME = "admin";
	private static final String PASSWORD = "123456";
	private static final String QUEUENAME = "hello";
	@Test
	public void mq_producer() throws IOException {
		//创建连接工厂
		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost(HOST);
		connectionFactory.setPort(PORT);
		connectionFactory.setUsername(USERNAME);
		connectionFactory.setPassword(PASSWORD);
		//设置虚拟主机连接
		connectionFactory.setVirtualHost("/");
		//从虚拟主机中获取一个连接
		Connection connection = connectionFactory.newConnection();
		//声明通道   一个TCP连接有可能多个通道
		Channel channel = connection.createChannel();
		//声明队列
		channel.queueDeclare(QUEUENAME, false, false, false, null);
		//定义需要发送的内容
		String msg = "hello rabbitmq2";
		//发布消息
		channel.basicPublish("",QUEUENAME,null,msg.getBytes());
		System.out.println("向"+QUEUENAME+"队列发送了:>>"+msg+"<<");
		channel.close();
		connection.close();
	}

	@Test
	public void mq_consumer() throws IOException, InterruptedException {
		//创建工厂
		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost(HOST);
		connectionFactory.setPort(PORT);
		connectionFactory.setUsername(USERNAME);
		connectionFactory.setPassword(PASSWORD);
		//设置发送的虚拟主机
		connectionFactory.setVirtualHost("/");
		//从工厂中获取连接
		Connection connection = connectionFactory.newConnection();
		//声明通道   一个TCP连接有可能多个通道
		Channel channel = connection.createChannel();
		//声明队列
		channel.queueDeclare(QUEUENAME,false,false,false,null);
		//定义队列的消费者
		QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
		//监听队列
		/*
            true:表示自动确认，只要消息从队列中获取，无论消费者获取到消息后是否成功消费，都会认为消息已经成功消费
            false:表示手动确认，消费者获取消息后，服务器会将该消息标记为不可用状态，等待消费者的反馈，
                   如果消费者一直没有反馈，那么该消息将一直处于不可用状态，并且服务器会认为该消费者已经挂掉，不会再给其
                   发送消息，直到该消费者反馈。
         */
		channel.basicConsume(QUEUENAME,true,queueingConsumer);
		//获取消息
		while (true){
			QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
			String msg = new String(delivery.getBody());
			System.out.println("从"+QUEUENAME+"队列中取出了消息:"+msg);
		}

	}
}

Work模式

即一个生产者多个消费者(work,像给老板打工一样)


/**
 * 
 * 如果设置了手动回复,且未回复消息,那么消息在RabbitMq里面是Unacked状态,
 * 每当一个消费者接入,消息会重新变成ready状态重新发送给该消费者,直到接收到回复
 * 如果消费者抛了异常,就会中断与消息队列的连接,由于中断与消息队列的连接相当于没有回复
 * 消息会重新回到队列中,继续发送给下一个消费者处理
 */
public class OneToMany {
    private static final String HOST = "192.168.101.210";
    private static final int PORT = 5672;
    private static final String USERNAME = "admin";
    private static final String PASSWORD = "123456";
    private static final String QUEUENAME = "hello";

    @Test
    public void producer() throws IOException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");
        //获取连接
        Connection connection = connectionFactory.newConnection();
        //声明通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUENAME,false,false,false,null);

        //发送消息
        for (int i=0;i<10;i++){
            String msg = "OneToMany-->>"+i;
            channel.basicPublish("",QUEUENAME,null,msg.getBytes());
        }
        channel.close();
        connection.close();
    }

    @Test
    public void consumer1() throws IOException, InterruptedException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");
        //获取连接
        Connection connection = connectionFactory.newConnection();
        //声明通道
        Channel channel = connection.createChannel();
        //能者多劳模式、服务器会选择处理完消息的消费者继续发送、如不加这句话无论处理完与否、都会按照平均分发的模式
        /*概念是每次给同一个消费者只发一条消息,在消费者没有反馈处理完该消息时不会再给该消费者发消息*/
        channel.basicQos(1);
        //声明队列
        channel.queueDeclare(QUEUENAME,false,false,false,null);
        //定义该队列的消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //监听队列,false为 手动返回消息状态
        channel.basicConsume(QUEUENAME,false,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            byte[] body = delivery.getBody();
            System.out.println("consumer1接收消息:"+new String(body));
            Thread.sleep(10);
            //手动返回消息给队列
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }
    }
    @Test
    public void consumer2() throws IOException, InterruptedException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");
        //获取连接
        Connection connection = connectionFactory.newConnection();
        //声明通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUENAME,false,false,false,null);
        //能者多劳模式、服务器会选择处理完消息的消费者继续发送、如不加这句话无论处理完与否、都会按照平均分发的模式
        /*概念是每次给同一个消费者只发一条消息,在消费者没有反馈处理完该消息时不会再给该消费者发消息*/
        channel.basicQos(1);
        //定义该队列的消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //监听队列,false为 手动返回消息状态
        channel.basicConsume(QUEUENAME,false,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            byte[] body = delivery.getBody();
            System.out.println("consumer1接收消息:"+new String(body));
            Thread.sleep(20);
            //手动返回消息给队列
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }
    }
}

发布订阅

即一个生产者发布，多个消费者共享

/**
 * 发布订阅模式,如果某个消费者挂掉,消息还是会直接存储在队列中,实际情况和一对多消费模式一样
 * 交换机一定要绑定队列,否则消息发送到交换机就会直接丢失(只有队列才有存储的功能)
 */
public class PublishSubscribe {

    private static final String HOST = "192.168.101.210";
    private static final int PORT = 5672;
    private static final String USERNAME = "admin";
    private static final String PASSWORD = "123456";
    private static final String QUEUENAME = "hello";
    private static final String QUEUENAME2 = "hello2";
    private static final String EXCHANGE_NAME = "fanout_exchange";

    @Test
    public void producer() throws IOException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");
        //获取连接
        Connection connection = connectionFactory.newConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //声明交换机    名字和类型
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        for(int i=0;i<10;i++){
            //创建消息
            String msg = "hello exchange"+i;
            //发布消息
            channel.basicPublish(EXCHANGE_NAME,"",null,msg.getBytes());
        }
        channel.close();
        connection.close();
    }


    @Test
    public void consumer1() throws IOException, InterruptedException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");
        //获取连接
        Connection connection = connectionFactory.newConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUENAME,false,false,false,null);
        //绑定队列到交换机
        channel.queueBind(QUEUENAME,EXCHANGE_NAME,"");
        //服务器每次只发送一条消息给一个消费者
        channel.basicQos(1);
        //定义队列的消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //监听队列,手动返回状态
        channel.basicConsume(QUEUENAME,false,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("consumer1消费消息:>>>"+new String(delivery.getBody()));
            //手动返回消息给服务器
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }
    }

    @Test
    public void consumer2() throws IOException, InterruptedException {
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");
        //获取连接
        Connection connection = connectionFactory.newConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUENAME2,false,false,false,null);
        //绑定队列到交换机
        channel.queueBind(QUEUENAME2,EXCHANGE_NAME,"");
        //服务器每次只发送一条消息给一个消费者
        channel.basicQos(1);
        //定义队列的消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //监听队列,手动返回状态
        channel.basicConsume(QUEUENAME2,false,queueingConsumer);
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            System.out.println("consumer2消费消息:>>>"+new String(delivery.getBody()));
            //手动返回消息给服务器
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }
    }
}

路由模式

即一个生产者，有选择的发送给多个消费者

public class Route {
    private static final String HOST = "192.168.101.210";
    private static final int PORT = 5672;
    private static final String USERNAME = "admin";
    private static final String PASSWORD = "123456";
    private static final String QUEUENAME = "hello";
    private static final String QUEUENAME2 = "hello2";
    private static final String EXCHANGE_NAME = "direct_exchange";
    @Test
    public void producer() throws IOException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");


        Connection connection = connectionFactory.newConnection();
        //声明信道
        Channel channel = connection.createChannel();
        //声明交换机类型为direct
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");
        //创建消息
        String msg = "Hello Direct !";
        Student s = new Student();
        s.setId(1);
        s.setName("呵呵呵吧");
        //发布消息
        channel.basicPublish(EXCHANGE_NAME,"select",null,Student.ObjectToByte(s));
        System.out.println("生产者发送了:"+msg);
        //关闭通道
        channel.close();
        //关闭连接
        connection.close();
    }


    @Test
    public void consumer1() throws IOException, InterruptedException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        //声明信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUENAME,false,false,false,null);
        //把队列绑定到交换机上,指定路由Key
        channel.queueBind(QUEUENAME,EXCHANGE_NAME,"update");
        channel.queueBind(QUEUENAME,EXCHANGE_NAME,"delete");
        channel.queueBind(QUEUENAME,EXCHANGE_NAME,"add");
        //同一时刻只发送一条消息给消费者
        channel.basicQos(1);
        //定义队列的消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //监听队列,手动返回完成状态
        channel.basicConsume(QUEUENAME,false,queueingConsumer);
        //获取消息
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            byte[] body = delivery.getBody();
            System.out.println("消费者1接收到消息:"+new String(body,"UTF-8"));
            //返回消息确认状态
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }

    }

    @Test
    public void consumer2() throws Exception {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        //声明通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUENAME2,false,false,false,null);
        //绑定队列到交换机,声明key为select
        channel.queueBind(QUEUENAME2,EXCHANGE_NAME,"select");
        //同一时刻只发送一条消息给消费者
        channel.basicQos(1);
        //定义队列的消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //监听队列,手动返回消息状态
        channel.basicConsume(QUEUENAME2,false,queueingConsumer);
        //获取消息
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            byte[] body = delivery.getBody();
            System.out.println("消费者2接收到消息:"+Student.ByteToObject(body));
            //手动返回确认状态
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }
    }
}

主题模式

和路由模式一样，不过消费者可以模糊匹配key来选择接收的消息

public class Topic {
    private static final String HOST = "192.168.101.210";
    private static final int PORT = 5672;
    private static final String USERNAME = "admin";
    private static final String PASSWORD = "123456";
    private static final String QUEUENAME = "hello";
    private static final String QUEUENAME2 = "hello2";
    private static final String EXCHANGE_NAME = "topic_exchange";
    @Test
    public void producer() throws IOException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");


        Connection connection = connectionFactory.newConnection();
        //声明信道
        Channel channel = connection.createChannel();
        //声明交换机类型为direct
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");
        //创建消息
        String msg = "Hello Topic !";
        Student s = new Student();
        s.setId(1);
        s.setName("呵呵呵吧");
        //发布消息
        channel.basicPublish(EXCHANGE_NAME,"select.from",null,Student.ObjectToByte(s));
        System.out.println("生产者发送了:"+msg);
        //关闭通道
        channel.close();
        //关闭连接
        connection.close();
    }


    @Test
    public void consumer1() throws IOException, InterruptedException {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        //声明信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUENAME,false,false,false,null);
        //把队列绑定到交换机上,指定路由Key
        channel.queueBind(QUEUENAME,EXCHANGE_NAME,"update.#");
        //同一时刻只发送一条消息给消费者
        channel.basicQos(1);
        //定义队列的消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //监听队列,手动返回完成状态
        channel.basicConsume(QUEUENAME,false,queueingConsumer);
        //获取消息
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            byte[] body = delivery.getBody();
            System.out.println("消费者1接收到消息:"+new String(body,"UTF-8"));
            //返回消息确认状态
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }

    }

    @Test
    public void consumer2() throws Exception {
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(HOST);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername(USERNAME);
        connectionFactory.setPassword(PASSWORD);
        connectionFactory.setVirtualHost("/");

        Connection connection = connectionFactory.newConnection();
        //声明通道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUENAME2,false,false,false,null);
        //绑定队列到交换机,声明key为select
        channel.queueBind(QUEUENAME2,EXCHANGE_NAME,"select.#");
        //同一时刻只发送一条消息给消费者
        channel.basicQos(1);
        //定义队列的消费者
        QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
        //监听队列,手动返回消息状态
        channel.basicConsume(QUEUENAME2,false,queueingConsumer);
        //获取消息
        while(true){
            QueueingConsumer.Delivery delivery = queueingConsumer.nextDelivery();
            byte[] body = delivery.getBody();
            System.out.println("消费者2接收到消息:"+Student.ByteToObject(body));
            //手动返回确认状态
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
        }
    }

}

 

qq_39205291
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mq的5种模式
qq_32384091的博客
06-21 8816
解说p生产者：发送消息的x交换机（转发器）：接受、推送消息q消息列队：接受、存取、推送消息（准备，未删除，总计）c消费者：接受消息1、默认情况，消费者一旦接受消息消息队列中的消息就会删除，并且只有消息列队有存储功2、交换机，消息列队一旦声明其属性无法修改，声明的与存在交换机，消息列队属性若不一致源码不报错，但运行时会报错3、生产者发送消息每执行一次basicPublish（）就发送一条消息，一、简...
MQ-消息队列的两种模式
陌上人如玉，公子世无双
06-24 1560
目录什么是MQMQ的好处消息队列的两种模式点对点模式发布/订阅模式异步和同步 什么是MQ MQ即消息队列。消息队列的含义是生产者与消费者通信时，把要传输的数据放到队列中。它被广泛应用在异步通信的领域中。 举个栗子： 老师希望学生多读书，经常给学生看一些好书，原来的方式是这样：老师需要等待学生课间的时候，把书给学生送去，并亲眼监督学生读完书才走。久而久之，老师和学生都觉得麻烦。 后来演进成：老师对学生说「我放到书架上的书你都要看」，然后老师每次发现不错的书都放到书架上，学生看到书架上有书就拿下来看。 此时的
rabbitmq常用三种模式的配置
03-16
rabbitmq包含多种模式，主要是fanout，direct，topic，本代码主要针对这三种模式进行相关的配置，配置文件单独放置在不同的文件夹里，以便学习。
RabbitMQ的使用场景和六种工作方式
weixin_43930956的博客
08-31 694
使用场景：* 服务解耦、流量削峰、异步调用 *（如支付成功后，安排外卖小哥就可以从消息队列去接收 订单执行寻找操作） Exchange： 在RabbitMQ中常用 direct、Fanout、Topic三种； RabbitMQ的六种工作模式（rabbitmq.amqp依赖） 简单模式：生产者发送信息，消费者接收信息 **工作模式：**一个生产者，多个消费者，轮询或者合理分发（每次接收一条信息，处理完再接收），消息持久化。 发布订阅模式：Exchange交换机Fanout，生产者只是声明Fanout，消
rabbitmq各种模式代码及说明
06-19
rabbitmq各种模式代码及说明，下载解压就能启动，集成springboot
rabbitMQ概述/在springboot下测试五种模式
weixin_44773418的博客
08-01 346
一、应用场景： (1) 异步操作: 任务异步处理将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。 (2) 解耦: 应用程序解耦合MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合 (3) 削峰: 在访问量剧增的情况下，应用仍然需要继续发挥作用，但是这样的突发流量并不常见；如果为以能处理这类峰值访问为标准来投入资源随时待命无疑是巨...
基于RabbitMQ几种Exchange 模式详解
08-28
基于RabbitMQ几种Exchange模式详解 本文将详细介绍RabbitMQ中四种Exchange模式：fanout、direct、topic、header。在实际应用中，header模式使用较少，本文将对前三种模式进行比较。 一、Fanout Exchange Fanout ...
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
消息队列RabbitMQ入门与5种模式详解
02-24
RabbitMQ是开源的，实现了AMQP协议的，采用Erlang(面向并发编程语言)编写的，可复用的企业级消息系统；AMQP（高级消息队列协议）是一个异步消息传递所使用应用层协议规范，为面向消息中间件设计，基于此协议的客户端...
rabbitMQ工作模式
qq_37846169的博客
08-01 514
rabbitmq工作模式
RabbitMQ的3种模式
qq_33732195的博客
02-20 325
直接模式（Direct） 我们需要将消息发给唯一一个节点时使用这种模式，这是最简单的一种形式； 任何发送到Direct Exchange的消息都会被转发到RouteKey中指定的Queue。 一般情况可以使用rabbitMQ自带的Exchange：”"(该Exchange的名字为空字符串，下文称其为default Exchange)。 这种模式下不需要将Exchange进行任何绑定(bindi...
消息队列的两种模式
热门推荐
和大黄的博客
12-01 7万+
Java消息服务（Java Message Service，JMS）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。 点对点与发布订阅最初是由JMS定义的。这两种模式主要区别或解决的问题就是发送到队列的消息能否重复消费(多订阅) 1、定义 JMS规范目前支持两种消息模型：点对点（point to poin
学习笔记：MQ的一些面试题的思考
u010609213的博客
09-29 187
学习笔记：MQ的一些面试题的思考MQ的一些面试题1、为什么要用消息中间件2、如何保证消息不丢失 MQ的一些面试题 1、为什么要用消息中间件 1.1系统解耦合 假如A系统的一些信息，下游有系统需要使用，难道每次都开发新的接口？这时候明显不合理，这个时候就把数据发送到MQ，有需要的系统自己去取，不需要的取消订阅/消费就行了。 1.2异步调用 假设你有一个系统调用链路，是系统A调用系统B，一般耗时20ms；系统B调用系统C，一般耗时200ms；系统C调用系统D，一般耗时2s，如果A调用之后是同步调用，那么一次请求
MQ: 消息队列常见应用场景及主流消息队列ActiveMQ、RabbitMQ、RocketMQ和Kafka的简单对比
韩超的博客 (hanchao5272)
08-21 4646
1.关于消息队列 消息队列，外文名Message Queue，简称MQ，是指在消息的传输中保存消息的容器或服务。 消息队列，是分布式系统实现高性能、高可用、可伸缩等高级特效的重要组件，适用多种场景，如：消息通讯、异步处理、应用解耦、流量削峰等等。 常见的主流消息队列：ActiveMQ、RabbitMQ、RocketMQ和Kafka。 2.应用场景 2.1.消息通讯 作为消息队列，其本职场景就是实现...
如何将实体转为 数组对象_java对象转成byte数组的3种方法
weixin_34515452的博客
02-05 2433
java对象转成byte数组，在使用netty进行通信协议传输的场景中是非常常见的。比如，协议有一些定好的协议头、classid，messageid等等信息，还有一个关键的内容是payload。不同的协议内容都会放到payload中，而这个payload往往就是一个byte数组。那么，如何方便的将一个java对象构造成一个byte数组呢？1 bytebuf填充我们以下面这个对象举例：public ...
RabbitMQ （二）工作队列
weixin_30396699的博客
07-10 340
转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/37620057 本系列教程主要来自于官网入门教程的翻译，然后自己进行了部分的修改与实验，内容仅供参考。 上一篇博客中我们写了通过一个命名的队列发送和接收消息，如果你还不了解请点击：RabbitMQ 入门 Helloworld。这篇中我们将会创建一个工作队列用来在工作...
rabbitmq 消息确认机制
泽佑兄弟 ZYbros
07-12 1万+
rabbitmq的消息确认机制分两部分 一部分是生产端，一部分是消费端 以下都是经过本人亲测得出的结论 环境版本： RabbitMQ 3.6.3, Erlang 19.0  rabbitmq-java-client-bin-3.6.3 生产端 消费端 首先通过producer往mq中放置了10个msg 然后通过debug断点方式consumer进
RabbitMQ的消息确认机制
aozhenza0058的博客
09-13 372
一、RabbitMQ消息确认机制 RabbitMQ的消息确认有两种：1、对生产端发送消息的确认。这种是用来确认生产者将消息发送给交换器，交换器传递给队列的过程中，消息是否成功投递。发送确认分为两步，一是确认是否到达交换器，二是确认是否到达队列。2、对消费端消费消息的确认。这种是确认消费者是否成功消费了队列中的消息。 二、RabbitMQ对生产端发送消息的确认 rabbitmq对生...
RabbitMQ采坑笔记
weixin_43189126的博客
04-24 5351
QueueingConsumer过时 QueueingConsumer在Rabbitmq客户端3.x版本中用的如火如荼，但是在4.x版本开初就被标记为@Deprecated。 Consumer的消费模式有Pull 和 Push两种，而经常用到的就是Push模式，Push模式在3.x的用法demo如下： QueueingConsumer consumer = new QueueingConsumer...
rabbitmq几种工作模式
最新发布
07-28
RabbitMQ有四种常见的工作模式，它们是：简单模式（Simple Mode）、工作模式（Work Mode）、发布/订阅模式（Publish/Subscribe Mode）和路由模式（Routing Mode）。 1. 简单模式（Simple Mode）：在简单模式下，一个生产者发送消息到一个队列，然后一个消费者从队列中接收并处理消息。 2. 工作模式（Work Mode）：在工作模式下，一个生产者发送消息到一个队列，多个消费者同时监听这个队列，每个消息只能被一个消费者处理。 3. 发布/订阅模式（Publish/Subscribe Mode）：在发布/订阅模式下，一个生产者发送消息到一个交换机（Exchange），交换机将消息广播给所有绑定到它的队列，每个队列都有自己的消费者。 4. 路由模式（Routing Mode）：在路由模式下，一个生产者发送消息到一个交换机，交换机根据消息的路由键（Routing Key）将消息发送给匹配的队列。消费者可以选择监听特定的队列来接收特定的消息。 这些工作模式可以根据实际需求来选择和组合使用，以满足不同场景下的消息传递需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值