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

最新推荐文章于 2024-06-04 09:08:12 发布

未来可期MXH

最新推荐文章于 2024-06-04 09:08:12 发布

阅读量1.5k

点赞数

分类专栏： RabbitMQ 文章标签： rabbitmq

本文链接：https://blog.csdn.net/qflyIT/article/details/106628891

版权

RabbitMQ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

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

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ之订阅模式与主题模式，消息确认机制

1.订阅模式作用类似与微信公众号，你订阅了就可以接收到消息解读:1.一个生产者,多个消费者。2.每一个消费者都有自己的队列3.生产者没有直搂把洧息发送到队列而是发到了交换机转发器exchange4.每个队列都要绑定到交换机上。5.生产者发送的消息经过交换机到达臥列就能实现一个消息到多个消费者消费1.2分发模式该模式下，生产者发送消息，多个消费者通过他们对应的队列获得消息，但是所获得的消息是一样的，不能指定将哪个消息给那个队列创建一个生产者public class send {
复制链接

扫一扫

专栏目录