RabbitMQ之订阅模式与主题模式，消息确认机制

最新推荐文章于 2024-08-16 13:50:17 发布
最新推荐文章于 2024-08-16 13:50:17 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qflyit/article/details/106628891
版权

1.订阅模式

作用类似与微信公众号，你订阅了就可以接收到消息

在这里插入图片描述解读:
1.一个生产者,多个消费者。
2.每一个消费者 都有自己的队列
3.生产者没有直搂把洧息发送到队列而是发到了交换机 转发器exchange
4.每个队列都要绑定到交换机上。
5.生产者发送的消息经过交换机到达臥列 就能实现一个消息到多个消费者消费

1.2分发模式fanout

该模式下，生产者发送消息，多个消费者通过他们对应的队列获得消息，但是所获得的消息是一样的，不能指定将哪个消息给那个队列

创建一个生产者

public class send {
    private static final String EXCHANGE_NAME="MXH_Exchange";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();
        ----声明一个交换机
        ----fanout：分发模式
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");

        String msg = "hello exchange";
        发送消息到交换机
        channel.basicPublish(EXCHANGE_NAME,"",null,msg.getBytes());

        channel.close();
        connection.close();
    }
}

创建第一个消费者

public class receive1 {
   private static final String EXCHANGE_NAME="MXH_Exchange";
   private static final String QUEUE_NAME="MXH_Exchange_note";
   public static void main(String[] args) throws IOException, TimeoutException {
       Connection connection = ConnectionUtil.getConnection();

       Channel channel = connection.createChannel();
       声明一个对列
       channel.queueDeclare(QUEUE_NAME,false,false,false,null);
       将队列绑定到交换机
       channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");
       一次应答前只发送一次
       channel.basicQos(1);

       DefaultConsumer consumer = new DefaultConsumer(channel)
       {
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope,
                                      AMQP.BasicProperties properties,
                                      byte[] body) throws IOException
           {
               String msg = new String(body);
               System.out.println("RE:"+msg);
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e)
               {
                   e.printStackTrace();
               }finally
               {
                   //手动应答
                   channel.basicAck(envelope.getDeliveryTag(),false);
               }
           }

       };
       boolean autoAck = false;//自动应答 true为开启 false为关闭
       channel.basicConsume(QUEUE_NAME,autoAck, consumer);

   }
}

创建第二个消费者

public class receiver2
{
    private static final String EXCHANGE_NAME="MXH_Exchange";
    private static final String QUEUE_NAME="MXH_Exchange_emain";
    public static void main(String[] args) throws IOException, TimeoutException
    {
        ------创建一个连接
        Connection connection = ConnectionUtil.getConnection();
        ------创建一个通道
        Channel channel = connection.createChannel();
        ------创建一个队列,用户名
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        ------将队列绑定到交换机
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");
        ------一次应答前只发送一次
        channel.basicQos(1);
        DefaultConsumer consumer = new DefaultConsumer(channel)
        {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException
            {
                String msg = new String(body);
                System.out.println("RE:"+msg);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }finally
                {
                    ------手动应答
                    channel.basicAck(envelope.getDeliveryTag(),false);

                }
            }
        };
        ------自动应答 true为开启 false为关闭
        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME,autoAck, consumer);
    }
}

2.Exchange交换机

作用：一方面是接收生产者的消息,另一方面是向队列推送消息。

2.1Fanout(不处理路由健)

匿名转发。
Fanout(不处理路由健)：对消息不作处理，消息不能指定发给特定的消费者

2.2Direct路由模式

交换机给队列发送消息时会在后面加一个Key，只有队列的Key和交换机的Key对应上，交换机才会把消息发给队列，如下图，交换机有error,info,warng三个Key，error的key对应c1和c2，所以带有error的key的消息就会发送给c1和c2
在这里插入图片描述
创建一个生产者
绑定key到交换机

public class send {
    private static final String EXCHANGE_NAME="MXH_Exchange";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();
        -----声明一个交换机
      -----fanout：分发模式  channel.exchangeDeclare(EXCHANGE_NAME,"direct");

        String msg = "hello direct";
        -----发送消息到交换机，绑定key到交换机
        String key ="love";
        channel.basicPublish(EXCHANGE_NAME,key,null,msg.getBytes());

        channel.close();
        connection.close();
    }
}

创建第一个消费者
绑定key到交换机

public class receive1 {
    private static final String EXCHANGE_NAME="MXH_Exchange";
    private static final String QUEUE_NAME="MXH_Exchange_note";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();
        //声明一个对列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //将队列绑定到交换机，绑定key到交换机
        String key ="error";
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,key);
        //一次应答前只发送一次
        channel.basicQos(1);

        DefaultConsumer consumer = new DefaultConsumer(channel)
        {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException
            {
                String msg = new String(body);
                System.out.println("RE:"+msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }finally
                {
                    //手动应答
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }

        };
        boolean autoAck = false;//自动应答 true为开启 false为关闭
        channel.basicConsume(QUEUE_NAME,autoAck, consumer);

    }
}

创建第二个消费者

public class receiver2
{
    private static final String EXCHANGE_NAME="MXH_Exchange";
    private static final String QUEUE_NAME="MXH_Exchange_emain";
    public static void main(String[] args) throws IOException, TimeoutException
    {
        //创建一个连接
        Connection connection = ConnectionUtil.getConnection();
        //创建一个通道
        Channel channel = connection.createChannel();
        //创建一个队列,用户名
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //将队列绑定到交换机，绑定key到交换机
        String key1 = "error";
        String key2 = "info";
        String key3 = "love";
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,key1);
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,key2);
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,key3);
        //一次应答前只发送一次
        channel.basicQos(1);
        DefaultConsumer consumer = new DefaultConsumer(channel)
        {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException
            {
                String msg = new String(body);
                System.out.println("RE:"+msg);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }finally
                {
                    //手动应答
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck = false;//自动应答 true为开启 false为关闭
        channel.basicConsume(QUEUE_NAME,autoAck, consumer);
    }
}

2.3Toplc exchanger主题模式

Toplc exchanger：将路由键和某模式匹配，
#匹配一个或者多个。
‘*’匹配一个。

第二个消费者：
注意我的key值： String key =“love.#”;
#代表多个，只要生产者发给交换机的key是love开头，这个消费者就能接收到
在这里插入图片描述在这里插入图片描述
创建一个生产者：
注意我的key值：String key =“love.del”;

public class send {
    private static final String EXCHANGE_NAME="MXH_Exchange_topic";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");//fanout：分发模式

        String msg = "hello direct";
        //发送消息到交换机
        String key ="love.del";
        channel.basicPublish(EXCHANGE_NAME,key,null,msg.getBytes());

        channel.close();
        connection.close();
    }
}

创建第一个消费者
注意我的key值： String key =“love.add”;

public class receive1 {
    private static final String EXCHANGE_NAME="MXH_Exchange_topic";
    private static final String QUEUE_NAME="MXH_Exchange_note";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();
        //声明一个对列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //将队列绑定到交换机
        String key ="love.add";
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,key);
        //一次应答前只发送一次
        channel.basicQos(1);

        DefaultConsumer consumer = new DefaultConsumer(channel)
        {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException
            {
                String msg = new String(body);
                System.out.println("RE:"+msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }finally
                {
                    //手动应答
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }

        };
        boolean autoAck = false;//自动应答 true为开启 false为关闭
        channel.basicConsume(QUEUE_NAME,autoAck, consumer);

    }
}

创建第二个消费者：
注意我的key值： String key =“love.#”;
#代表多个，只要生产者发给交换机的key是love开头，这个消费者就能接收到

public class receiver2
{
    private static final String EXCHANGE_NAME="MXH_Exchange_topic";
    private static final String QUEUE_NAME="MXH_Exchange_emain";
    public static void main(String[] args) throws IOException, TimeoutException
    {
        //创建一个连接
        Connection connection = ConnectionUtil.getConnection();
        //创建一个通道
        Channel channel = connection.createChannel();
        //创建一个队列,用户名
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //将队列绑定到交换机
        String key = "love.#";
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,key);
        //一次应答前只发送一次
        channel.basicQos(1);
        DefaultConsumer consumer = new DefaultConsumer(channel)
        {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException
            {
                String msg = new String(body);
                System.out.println("RE:"+msg);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }finally
                {
                    //手动应答
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck = false;//自动应答 true为开启 false为关闭
        channel.basicConsume(QUEUE_NAME,autoAck, consumer);
    }
}

消息确认机制

在rabbitmq中我们可以通过持久化数据解决rabbitmq服务器异常的数据丢失问题。

问题:生产者将消息发送出去之后,消息到底有没有到达rabbitmq 服务器默认的情况是不知道的;

两种方式可以知道:
1.AMQP实现的事务机制
2.Confirm横式

AMQP实现的事务机制

AMQP提供了三个方法
channel.txSelect();-----开启事物：在消息发送前开启
channel.txCommit();-----提交事物：在消息发送后提交
channel.txRollback();-----事物回滚：如果有异常就回滚，处理异常

这种模式增加了服务器的请求量，使服务器处理的效率降低

public class send {
    private static final String QUEUE_NAME="MXH";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //创建一个连接
        Connection connection = ConnectionUtil.getConnection();
        //从连接中获取一个通道
        Channel channel = connection.createChannel();
        //创建一个消息队列  QUEUE_NAME：队列名
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

            try
            {


            String msg = "hello,rqbbitmq你好";
            channel.txSelect();-----开启事物
            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            int i =1/0;
            channel.txCommit();-----提交事物
            }catch (Exception e)
            {
                channel.txRollback();-----事物回滚
                System.out.println("发送异常，消息未送达");
            }

        channel.close();
        connection.close();
    }
}

Confirm横式

原理

生产者将信道设置成confirm横式，一旦信道进入confirm横式，所有在该信道上面发布的洧息都会被指很一个唯一的ID(从1开始)。一旦洧息被投递到所有匹配的队列之后，broker就会发送-一个确认给生产者(包含消息的唯一ID) .这就使得生产者知道消息已经正确到达目的队列了。如果消息和队列是可持久化的，那么确认消息会将消息写入磁盘之后发出，broker 固传给生产者的确认消息中deliver-tag 域包含了确认消息的序列号，此外broker也可以设置basic.ack 的multiple城，表示到这个序列号之前的所有消息都已经得到了处理。。

Confirm摸式最大的好处在于他是异步。

串行模式

channel.confirmSelect();//开启confirm模式
channel.waitForConfirms()：该方法在生产者发送消息到队列后会返回true
if(channel.waitForConfirms())
{
System.out.println(“发送成功”);
}else
{
System.out.println(“发送失败”);
}
普通模式：该模式一次发送一条消息到队列，一发一回

public class send {
    private static final String QUEUE_NAME="MXH_confirm";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //创建一个连接
        Connection connection = ConnectionUtil.getConnection();
        //从连接中获取一个通道
        Channel channel = connection.createChannel();
        //创建一个消息队列  QUEUE_NAME：队列名
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        try {

          channel.confirmSelect();//开启confirm模式
            String msg = "hello,rqbbitmq你好";
            int i =1/0;
            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            if(channel.waitForConfirms())
            {
                System.out.println("发送成功");
            }else
            {
                System.out.println("发送失败");
            }
        }catch (Exception e)
        {
            System.out.println("发送失败");
        }

        channel.close();
        connection.close();
    }
}

批量模式：该模式用for循环发送多条数据，多发一回，发完所有的消息服务器回一条是否收到消息

public class send {
    private static final String QUEUE_NAME="MXH_confirm";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //创建一个连接
        Connection connection = ConnectionUtil.getConnection();
        //从连接中获取一个通道
        Channel channel = connection.createChannel();
        //创建一个消息队列  QUEUE_NAME：队列名
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        try {

          channel.confirmSelect();//开启confirm模式
            String msg = "hello,rqbbitmq你好";
            int i =1/0;
            for(int p =0;p<10;p++)
            {
                channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            }

            if(channel.waitForConfirms())
            {
                System.out.println("发送成功");
            }else
            {
                System.out.println("发送失败");
            }
        }catch (Exception e)
        {
            System.out.println("发送失败");
        }

        channel.close();
        connection.close();
    }
}

异步模式

原理

Channel对象提供的Confirmlistener回调方法只包含deliveryTag (当前Chanel发出的消息序号)。我们需要自己为每一个Channel維护一个unconfirm的消息序号集合，每publish 一条数据，集合中元素加1.每回调一次handleAck方法，unconfirm 集合删掉相应的一条(multiple=false)或多条(multiple=true)记录。从程序运行效率上看，这个unconfirm集合最好采用有序集合SortedSet存储结构。

创建一个生产者：

public class send {
    private static final String QUEUE_NAME="MXH_confirm";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException
    {
        //创建一个连接
        Connection connection = ConnectionUtil.getConnection();
        //从连接中获取一个通道
        Channel channel = connection.createChannel();
        //创建一个消息队列  QUEUE_NAME：队列名
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

            channel.confirmSelect();//开启confirm模式
            ----未确认的消息标识
            final SortedSet<Long> confirmSet = Collections.synchronizedSortedSet(new TreeSet<Long>());
            ----添加通道监听
            channel.addConfirmListener(new ConfirmListener()
            {
                @Override
               -----消息发送成功
                public void handleAck(long deliveryTag , boolean mulpitle) throws IOException
                {
                    if (mulpitle) {
                        confirmSet.headSet(deliveryTag  + 1).clear();
                    } else {
                        confirmSet.remove(deliveryTag );
                    }
                }

                @Override
                -----消息发送失败
                public void handleNack(long deliveryTag , boolean mulpitle) throws IOException {
                    if (mulpitle) {
                        confirmSet.headSet(deliveryTag  + 1).clear();
                    } else {
                        confirmSet.remove(deliveryTag );
                    }
                }
            });

            String msg = "hello,rqbbitmq你好";
        while(true)
        {
            long setNo = channel.getNextPublishSeqNo();
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
            confirmSet.add(setNo);
        }
//        channel.close();
//        connection.close();
    }
}

spring整合rabbitMQ

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

在这里插入图片描述

未来可期MXH
关注
专栏目录
RabbitMQ消息队列的工作模式
江晓龙的博客
06-26 1万+
使用Routing路由模式时，Exchange与队列也不再进行绑定了，而是通过声明一个RoutingKey，通过这个key将消息路由到特定的队列中，因此在消息发送方发消息时，就需要指定消息的RoutingKey，Routing根据消息中的RoutingKey进行判断，当消息中的RoutingKey与队列中的RoutingKey完全一致时，消息才能正常存储到队列中，最后被消费者处理。简而言之，使用Topic模式后，可以对消息数据中的RoutingKey进行通配符匹配，将满足条件的消息数据分发到特定的队列中。
RabbitMQ高级特性 - 消费者消息确认机制
CYK_byte的博客
08-04 1372
为了保证消息从 队列 到 消费者正确消费，那么就引入了消费者消息确认机制.a）消费者在订阅队列时，可以指定 autoAck 参数，根据这个参数设置，消息确认机制分为以下两种（以下讲到的方法和参数来自于 RabbitMQ 原生的 SDK，非 Spring 提供）.自动确认：当 autoAck = true 时，RabbitMQ 会自动把发送出去的消息置为确认，然后不管消费者是否真正的消费这些消息，都会从内存中删除.（适合对消息可靠性要求不高的场景）.
RabbitMQ 入门之发布订阅模式
qq_44157349的博客
03-03 2338
RabbitMQ 入门之发布订阅模式RabbitMQ 的结构RabbitMQ 的六种模式SpringAMQPFanout Exchange 广播模式Direct Exchange 路由模式Topic Exchange 主题模式消息转换器 前面已经提过了引入 MQ 的优点，解耦、异步和流量削峰，这里不再赘述。 RabbitMQ 的结构 RabbitMQ 有几个个概念： RoutingKey 路由键，在发布订阅模型中根据 RoutingKey 可以找到具体队列。 Publisher 生产者，生产消息发送给 E
MQ的订阅模式
weixin_33755649的博客
03-19 700
一：介绍 1.模式 　　   2.使用场景 　　一个生产者，多个消费者 　　每一个消费者都有自己的队列 　　生产者没有直接把消息发送给队列，而是发送到了交换机 　　每一个队列都要绑定到交换机 　　可以实现一个消息被多个消费者消费。   二：程序 1.生产者 1 package com.mq.PubSubFanout; 2 3 import com.mq.utils.ConnectionU...
RabbitMQ发布订阅模式Publish/Subscribe详解
最新发布
yinying293的博客
08-16 1947
今天介绍了基于API方式、配置类方式和注解的3种消息队列，并展示了实现发布订阅Publish/Subscribe模式的整合及代码实现，基于注解方式的实现需要重点掌握。有关RabbitMQ的其他内容，袁老后续更新。
RabbitMQ工作模式(3) - 订阅模式
weixin_45751763的博客
04-19 1257
在这种模式中，消息发送者（发布者）将消息发送到一个交换机（exchange），交换机将消息广播到所有与之绑定的队列，然后消费者（订阅者）可以从这些队列中接收消息。这里方便区分，新建了文件SubConfig，每个工作模式创建队列和交换机的过程区分开，全都配置到RabbitmqConfig文件中也是可以的，同时也可以通过RabbitAdmin进行绑定（另一种方式）。： 每个消费者接收到广播的消息后，进行相应的处理。可以发现，发布/订阅模式下，推送到交换机的消息，会被所有绑定了交换机的队列接收。
RabbitMQ发布/订阅模式（Publish/Subscribe）
诚的博客
11-09 849
工作队列模式是直接在生产者与消费者里声明好一个队列，这种情况下消息只会对应同类型的消费者。 　　举个用户注册的列子：用户在注册完后一般都会发送消息通知用户注册成功（失败）。如果在一个系统中，用户注册信息有邮箱、手机号，那么在注册完后会向邮箱和手机号都发送注册完成信息。利用MQ实现业务异步处理，如果是用工作队列的话，就会声明一个注册信息队列。注册完成之后生产者会向队列提交一条注册数据，消费者取出数据同时向邮箱以及手机号发送两条消息。但是实际上邮箱和手机号信息发送实际上是不同的业务逻辑，不应该放在一块处理。这
RabbitMQ发布订阅模式-fanout、direct、topic
qq_53799708的博客
08-25 355
RabbitMq的发布订阅模式的三种交换机的实现代码
RabbitMQ之消息模式简单易懂，超详细分享~~~
m0_56069948的博客
09-13 693
上一篇对RabbitMQ的流程和相关的理论进行初步的概述，如果小伙伴之前对消息队列不是很了解，那么在看理论时会有些困惑，这里以消息模式为切入点，结合理论细节和代码实践的方式一起来学习。RabbitMQ提供了多种模式应对各种业务，但匹配条件越是模糊或者参数化，那性能相对比较弱。再回顾一些常用的消息队列组件，是不是很多都是默认使用Direct模式，精确匹配的RoutingKey可以针对具体不同业务处理，匹配性能也相对比较高；当然其他模式小伙伴也可以针对业务情况进行使用。
RabbitMQ的消息模式
大人的博客
03-11 1185
1.简单模式 简单模式是最简单的消息模式，它包含一个生产者、一个消费者和一个队列。生产者向队列里发送消息，消费者从队列中获取消息并消费。 2.工作模式 工作模式是指向多个互相竞争的消费者发送消息的模式，它包含一个生产者、两个消费者和一个队列。两个消费者同时绑定到一个队列上去，当消费者获取消息处理耗时任务时，空闲的消费者从队列中获取并消费消息。 ...
RabbitMQ下的生产消费者模式与订阅发布模式
茅庐
12-11 2万+
生产消费者模式与订阅发布模式是使用消息中间件时常用的两种模式，用于功能解耦和分布式系统间的消息通信。本文在总结了RabbitMQ核心概念的基础上，以“数据接入”和“事件分发”两个场景来探讨如何实现生产消费者模式和订阅发布模式。
ActiveMQ 使用主题发布消息与两种订阅模式的差异
jym的博客
04-29 985
ActiveMQ 使用主题发布消息： 说明： 生产者将消息发布到topic中，每个消息可以有多个消费者，属于1：N的关系 生产者和消费者有时间关联性，订阅某一个主题的消费者，只能消费他订阅之后的消息 生产者生产消息时，topic 不保存消息它是无状态不落地，假如无人订阅就去生产，那就是一条废消息，所以，一般是先启动消费者，在启动生产者 1.启动 ActiveMQ 服务端 2.创建工程 添加po...
RabbitMQ 常见的消息模型：基本消息队列、工作消息队列、发布订阅
qq_52889347的博客
03-17 732
RabbitMQ 常见的消息模型：基本消息队列、工作消息队列、发布订阅
RabbitMQ (七) 订阅者模式之主题模式 ( topic )
weixin_30642267的博客
02-06 340
主题模式和路由模式很像 路由模式是精确匹配 主题模式是模糊匹配 依然先通过管理后台添加一个交换机. 生产者 public class Producer { private const string ExchangeName = "test_exchange_topic"; public static void ...
rabbitmq主题订阅
皇甫嗷嗷叫
10-15 701
rabbitmq主题订阅 一、topic 模式交换机 上一篇文章讲述了关于直接连接交换机根据key找到对应队列的方式，实现特殊消息特殊队列消费的目的，但是事实上，生产环境下，对于消息的复杂性远不是这样就能够解决的！比如：你要监控有个用户的操作行为，用户的操作行为太多了 增删改查，如果一个一个的写难免会有遗漏，这个时候，我们可以用通配符 user.* 轻松解决！这就是mq的主题模式！ 这里的交换机...
消息队列中点对点与发布订阅区别
热门推荐
李志涛的专栏
08-17 4万+
背景知识JMS一个在 Java标准化组织（JCP）内开发的标准（代号JSR 914）。2001年6月25日，Java消息服务发布JMS 1.0.2b，2002年3月18日Java消息服务发布 1.1. Java消息服务（Java Message Service，JMS）应用程序接口是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信
五、交换机 与 发布/订阅模式、路由模式、主题模式
wang_luwei的博客
03-19 711
交换机
rabbitmq工作模式之发布与订阅模式、Routing 路由模式、Topics 主题模式
qq_41931364的博客
11-30 1536
rabbitmq工作模式之发布与订阅模式、Routing 路由模式、Topics 主题模式1、发布与订阅模式1.1、消费者1.2、生产者1.3、运行测试2、Routing 路由模式2.1、消费者2.2、生产者3.3、运行测试3、Topics 主题模式3.1、消费者3.2、生产者3.3、运行测试 基于上篇博客的基础 1、发布与订阅模式 发布与订阅模式中多一个交换机的角色，也就是生产者生产出消息之后不会直接放进队列，而是会交给交换机，由交换机取交给自己绑定的队列，然后消费者再去队列里面拿，如下图所示： 1
[rabbitMQ]八、rabbitMQ队列之主题模式（topic）
qq_39545346的博客
05-20 481
基于多个标准执行路由操作：在我们的日志系统中，我们不只希望订阅基于严重程度的日志，同时还希望订阅基于发送来源的日志。 主题交换机 发送到主题交换机（topic exchange）的消息不可以携带随意什么样子的路由键（routing_key），它的路由键必须是一个由.分隔开的词语列表。这些单词随便是什么都可以，但是最好是跟携带它们的消息有关系的词汇。以下是几个推荐的例子：“stock.usd.nyse”, “nyse.vmw”, “quick.orange.rabbit”。词语的个数可以随意，但是不要超过25
C# .net 6中RabbitMQ发布订阅模式的封装实现
发布订阅模型是RabbitMQ中的一种消息传递模式，允许消息发送者（发布者）向消息队列发送消息，而不需要关心接收者（订阅者）是谁。在这种模式下，订阅者会订阅一个特定的交换机，并且能够接收到所有被发布到该交换机...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值