RabbitMQ学习笔记之五种模式及消息确认机制

最新推荐文章于 2024-03-30 22:00:37 发布
最新推荐文章于 2024-03-30 22:00:37 发布
阅读量264 收藏
点赞数
分类专栏： RabbitMQ 文章标签： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q1075988537/article/details/102657308
版权

本文详细介绍简单模式Simple、工作模式Work、发布订阅模式Publish/Subscribe、Topic、Routing。

Maven依赖引用

<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.11</version>
		</dependency>

		<dependency>
			<groupId>com.rabbitmq</groupId>
			<artifactId>amqp-client</artifactId>
			<version>4.0.2</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.7.10</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>1.7.5</version>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>
	</dependencies>

连接RabbitMQ服务公用方法

package com.test.testboot.mq;


import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ConnectionUtil {
    /**
     * 获取MQ的连接
     * @return
     * @throws IOException
     * @throws TimeoutException
     */
    public static Connection getConection() throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //设置服务地址
        factory.setHost("127.0.0.1");
        //设置服务端口号
        factory.setPort(5672);
        //设置Host
        factory.setVirtualHost("/");
        //设置用户名
        factory.setUsername("");
        //设置密码
        factory.setPassword("123456");
        return factory.newConnection() ;
    }
}

模式1：简单队列模式(Simple)

消息生产者p将消息放入队列
消费者监听队列,如果队列中有消息,就消费掉,消息被拿走后,自动从队列删除
(隐患,消息可能没有被消费者正确处理,已经消失了,无法恢复)

应用场景:聊天室

  • 生产者
package com.test.testboot.mq;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Sender {

    private static String QUEUE_NAME="test_simple_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取一个连接
        Connection connection=ConnectionUtil.getConection();
        //获取一个通道
        Channel channel=connection.createChannel();
        //创建队列声明
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        String msg="Hello World!";
        System.out.println("sendMsg："+msg);
        channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());

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


    }
}
  • 消费者
package com.test.testboot.mq;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Recv {
    private static String QUEUE_NAME="test_simple_queue";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取连接
        Connection connection=ConnectionUtil.getConection();
        //创建通道
        Channel channel = connection.createChannel();
        //定义队列消费者
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //获取到达的消息
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String recvMsg = new String(body, "UTF-8");
                System.out.println("recvMsg:" + recvMsg);
            }
        };

        channel.basicConsume(QUEUE_NAME,true,defaultConsumer);;
        //老版本api
      /*  QueueingConsumer comsumer= new QueueingConsumer(channel);

         channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //监听队列
        channel.basicConsume(QUEUE_NAME,true,comsumer);

        while(true){
            QueueingConsumer.Delivery delivery=comsumer.nextDelivery();
            String recvMsg=new String(delivery.getBody());
            System.out.println("recvMsg:"+recvMsg);
        }*/

    }
}

模式2:工作模式(Work)

生产者将消息放入队列
多个消费者同时监听同一个队列,消息如何被消费?(与具体的分发方式有关系)
C1,C2共同争抢当前消息队列的内容,谁先拿到消息,谁来负责消费
应用场景:红包;大型项目中的资源调度过程(直接由最空闲的系统争抢到资源处理任务)

  • 轮询分发（Round-Robin）

    • 生产者
package com.test.testboot.mq.work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Send {
    /*
     *               |--C1
     * p-----Queue---|
     *               |--C2
     */

    private static final String QUEUE_NAME="test_work_queue";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取连接
        Connection conection = ConnectionUtil.getConection();

        //获取Channel
        Channel channel = conection.createChannel();

        //声明队列

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        for (int i = 0; i <10 ; i++) {
            String  msg="Hello"+i;
            System.out.println("[WorkQueue] Send ："+msg);
            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            Thread.sleep(i*10);
        }
        channel.close();
        conection.close();
    }

}
  • 消费者1
package com.test.testboot.mq.work;

import com.rabbitmq.client.*;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Recv1 {
    private static final String QUEUE_NAME="test_work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection conection = ConnectionUtil.getConection();

        //获取Channel
        Channel channel = conection.createChannel();

        //声明队列

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //定义一个消费者
        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,"UTF-8");

                System.out.println("Recv[1] recv msg:"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("Recv[1] down");
                }
            }
        };
        /*
            true:表示自动确认,只要消息从队列中获取,无论消费者获取到消息后是否成功消费,都会认为消息成功消费.
            false:表示手动确认,消费者获取消息后,服务器会将该消息标记为不可用状态,等待消费者的反馈,
            如果消费者一直没有反馈,那么该消息将一直处于不可用状态,并且服务器会认为该消费者已经挂掉,不会再给其发送消息,
            直到该消费者反馈.
        */
        boolean autoAck=true;
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);
    }
}
  • 消费者2
package com.test.testboot.mq.work;

import com.rabbitmq.client.*;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Recv2 {
    private static final String QUEUE_NAME="test_work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection conection = ConnectionUtil.getConection();

        //获取Channel
        Channel channel = conection.createChannel();

        //声明队列

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //定义一个消费者
        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,"UTF-8");

                System.out.println("Recv[2] recv msg:"+msg);

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("Recv[2] down");
                }
            }
        };
        boolean autoAck=true;
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);
    }
}

  • 公平分发（Work Fair）

  • 生产者
package com.test.testboot.mq.workfair;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Send {
    /*
     *               |--C1
     * p-----Queue---|
     *               |--C2
     */

    private static final String QUEUE_NAME="test_work_queue";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取连接
        Connection conection = ConnectionUtil.getConection();

        //获取Channel
        Channel channel = conection.createChannel();

        //每个消费者 发送确认消息之前，消息队列不发送下一个消息到消费者，一次只处理一个消息
        //限制发送给同一个消费者不得超过一条消息
        channel.basicQos(1);

        //声明队列

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        for (int i = 0; i <10 ; i++) {
            String  msg="Hello"+i;
            System.out.println("[WorkQueue] Send ："+msg);
            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            Thread.sleep(i*5);
        }
        channel.close();
        conection.close();
    }

}
  • 消费者1
package com.test.testboot.mq.workfair;

import com.rabbitmq.client.*;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Recv1 {
    private static final String QUEUE_NAME="test_work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection conection = ConnectionUtil.getConection();

        //获取Channel
        Channel channel = conection.createChannel();

        //声明队列

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //每次只分发一个
        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,"UTF-8");

                System.out.println("Recv[1] recv msg:"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("Recv[1] down");
                    //手动回执
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=false; //自动应答
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);
    }
}
  • 消费者2
package com.test.testboot.mq.workfair;

import com.rabbitmq.client.*;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Recv2 {
    private static final String QUEUE_NAME="test_work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection conection = ConnectionUtil.getConection();

        //获取Channel
       final Channel channel = conection.createChannel();
        channel.basicQos(1);
        //声明队列

        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //定义一个消费者
        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,"UTF-8");

                System.out.println("Recv[2] recv msg:"+msg);

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("Recv[2] down");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=false;//自动应答
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);
    }
}

模式三：订阅模式(publish/subscribe)

生产者将消息交给交换机
有交换机根据发布订阅的模式设定将消息同步到所有的绑定队列中;
后端的消费者都能拿到消息

应用场景:短信、邮件群发,群聊天,广告

  • 生产者
package com.test.testboot.mq.ps;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Send {
    /*
     *                           |--C1
     * p---exchange----Queue-----|
     *                           |--C2
     */

    private static final String EXCHANGE_NAME="test_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取连接
        Connection conection = ConnectionUtil.getConection();

        //获取Channel
        Channel channel = conection.createChannel();

        //声明交换机
       channel.exchangeDeclare(EXCHANGE_NAME,"fanout");

        String  msg="Hello";
        System.out.println("Send ："+msg);
        channel.basicPublish(EXCHANGE_NAME,"",null,msg.getBytes());


        channel.close();
        conection.close();
    }

}
  • 消费者1
package com.test.testboot.mq.ps;

import com.rabbitmq.client.*;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Recv1 {
    private static final String QUEUE_NAME="test_queue_fanout_email";
    private static final String EXCHANGE_NAME="test_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection conection = ConnectionUtil.getConection();

        //获取Channel
        Channel channel = conection.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,"UTF-8");

                System.out.println("[1] recv msg:"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[1] down");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=false;
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);
    }
}
  • 消费者2
package com.test.testboot.mq.ps;

import com.rabbitmq.client.*;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Recv2 {
    private static final String QUEUE_NAME="test_queue_fanout_sms";
    private static final String EXCHANGE_NAME="test_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection conection = ConnectionUtil.getConection();

        //获取Channel
        Channel channel = conection.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,"UTF-8");

                System.out.println("[2]recv msg:"+msg);

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[2] down");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=true;
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);
    }
}

模式四：路由模式（Routing）

生产者发送消息到交换机,同时绑定一个路由Key,交换机根据路由key对下游绑定的队列进行路
由key的判断,满足路由key的队列才会接收到消息,消费者消费消息

应用场景: 项目中的error报错

  • 生产者
package com.test.testboot.mq.routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @description: 路由模式生产者
 * @author: Mr.ADiao
 * @create: 2019-10-21 11:04
 **/
public class Send {
    private  static final String EXCHANGE_NAME="test_exchange_direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        //获取连接
        Connection conection = ConnectionUtil.getConection();
        //创建频道
        Channel channel = conection.createChannel();

        channel.basicQos(1);

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        String msg="Hello Routing";
        String routingKey="warning";

        channel.basicPublish(EXCHANGE_NAME,routingKey,null,msg.getBytes());
        System.out.println("send:"+msg);
        channel.close();
        conection.close();
    }
}
  • 消费者1
package com.test.testboot.mq.routing;

import com.rabbitmq.client.*;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;


public class Recv1 {
    private static final String  EXCHANGE_NAME="test_exchange_direct";
    private static final String QUEUE_NAME="test_queue_direct1";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "error");


        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,"UTF-8");

                System.out.println("[1] recv msg:"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[1] down");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=false;
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);

    }
}
  • 消费者2
package com.test.testboot.mq.routing;

import com.rabbitmq.client.*;
import com.test.testboot.mq.ConnectionUtil;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @description: 路由模式消费者2
 * @author: Mr.ADiao
 * @create: 2019-10-21 11:05
 **/
public class Recv2 {
    private static final String  EXCHANGE_NAME="test_exchange_direct";
    private static final String QUEUE_NAME="test_queue_direct2";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);


        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "error");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "info");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "warning");

        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,"UTF-8");

                System.out.println("[2] recv msg:"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[2] down");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=false;
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);

    }
}

模式五：主题模式（Topics）

topic模式也称为通配符模式，其实他相对于routing模式最大的好处就是他多了一种匹配模式的路由，怎么理解匹配呢，其实就相当于我们之前正则的.*这种，不过他的匹配机制可能不是这种（其实除了匹配规则外，他的作用就和routing模式一样 ）

匹配规则：

绑定键binding key也必须是这种形式。以特定路由键发送的消息将会发送到所有绑定键与之匹配的队列中。但绑定键有两种特殊的情况： 
①*（星号）仅代表一个单词 
②#（井号）代表任意个单词

示例：

*.apple.* :  匹配以 任意一个单词字符开头中间包含 .orange. 以任意一个单词字符结尾 的字符串。比如 a.apple.b, asd.apple.qewf 等（注意是一个单词）。

log.# ：只要一lay.开头的都匹配，他可以匹配product.a,product.a.b, product.b.c等。

  • 生产者
package com.adiao.rabbitmq.topics;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.adiao.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Send {

	private static final String EXCHANGE_NAME="test_exchange_topic";
	public static void main(String[] args) throws IOException, TimeoutException {

		Connection connection = ConnectionUtils.getConnection();
		
		Channel channel = connection.createChannel();
		
		channel.exchangeDeclare(EXCHANGE_NAME, "topic");
		
		channel.basicQos(1);
		
		String msg="This is Topic Msg";
		
		channel.basicPublish(EXCHANGE_NAME, "myTopic.key2", null, msg.getBytes());
		
		System.out.println("Send:"+msg);
		
		channel.close();
		
		connection.close();
	}

}
  • 消费者1
package com.adiao.rabbitmq.topics;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.adiao.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

public class Recv1 {
	private static final String EXCHANGE_NAME="test_exchange_topic";
	private static final String QUEUE_NAME="test_queue_topic1";
	public static void main(String[] args) throws IOException, TimeoutException {

		Connection connection = ConnectionUtils.getConnection();
		
		Channel channel = connection.createChannel();
		
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		
		channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "myTopic.#");
		
		channel.basicQos(1);
		
		DefaultConsumer consumer = new DefaultConsumer(channel){
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope,
					BasicProperties properties, byte[] body) throws IOException {
				
				System.out.println("[1] Recv:"+new String(body,"UTF-8"));
				
				//手动回执
				channel.basicAck(envelope.getDeliveryTag(), false);
			}
		};
		
		channel.basicConsume(QUEUE_NAME, false, consumer);
	}

}
  • 消费者2
package com.adiao.rabbitmq.topics;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.adiao.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

public class Recv2 {
	
	
	private static final String EXCHANGE_NAME="test_exchange_topic";
	private static final String QUEUE_NAME="test_queue_topic2";
	public static void main(String[] args) throws IOException, TimeoutException {

		Connection connection = ConnectionUtils.getConnection();
		
		Channel channel = connection.createChannel();
		
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		
		channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "myTopic.key1");
		
		channel.basicQos(1);
		
		DefaultConsumer consumer = new DefaultConsumer(channel){
			
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope,
					BasicProperties properties, byte[] body) throws IOException {
				
				System.out.println("[2]Recv:"+new String(body,"UTF-8"));
				
				channel.basicAck(envelope.getDeliveryTag(), false);
			}
		};
		
		channel.basicConsume(QUEUE_NAME, false, consumer);
	}

}

  • 消息确认机制之事务机制

AMQP协议自带机制

弊端：降低RabibtMQ的吞吐量

  • 生产者
package com.adiao.rabbitmq.tx;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.adiao.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Send {

	private static final String QUEUE_NAME="test_queue_tx";
	public static void main(String[] args) throws IOException, TimeoutException {
		
		Connection connection = ConnectionUtils.getConnection();
		
		Channel channel = connection.createChannel();
		
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		
		String msg="This is tx";
		
		
		try {
			//开启事务
			channel.txSelect();
			channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
			int i=1/0;
			System.out.println("Send"+msg);
			//提交事务
			channel.txCommit();
		} catch (Exception e) {
			e.printStackTrace();
			//回滚事务
			channel.txRollback();
			System.out.println("rollback");
		}
		channel.close();
		connection.close();
		
	}

}
  • 消费者
package com.adiao.rabbitmq.tx;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.adiao.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

public class Recv {

	private static final String QUEUE_NAME = "test_queue_tx";

	public static void main(String[] args) throws IOException, TimeoutException {

		Connection connection = ConnectionUtils.getConnection();

		Channel channel = connection.createChannel();

		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		
		channel.basicConsume(QUEUE_NAME, true, new DefaultConsumer(channel){
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope,
					BasicProperties properties, byte[] body) throws IOException {
				
				System.out.println("Recv:"+new String(body,"UTF-8"));
			}
		});
	}

}

  • 消息确认机制之Confirm同步确认

生产者

package com.adiao.rabbitmq.confirm;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.adiao.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Send {
	private static final String QUEUE_NAME="test_queue_confirm";
	public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
		Connection connection = ConnectionUtils.getConnection();
		
		Channel channel = connection.createChannel();
		
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		
		//单条开启
		channel.confirmSelect();
		
		String msg="This is Confirm";
		
		channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
		
		if(!channel.waitForConfirms()){
			System.out.println("Send Faile");	
		}else{
			System.out.println("Send Success");	
		}
		
		channel.close();
		connection.close();
	}

}

消费者

package com.adiao.rabbitmq.confirm;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.adiao.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

public class Recv {

	private static final String QUEUE_NAME = "test_queue_confirm";

	public static void main(String[] args) throws IOException, TimeoutException {

		Connection connection = ConnectionUtils.getConnection();

		final Channel channel = connection.createChannel();

		channel.queueDeclare(QUEUE_NAME, false, false, false, null);

		channel.basicConsume(QUEUE_NAME, false, new DefaultConsumer(channel) {
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope,
					BasicProperties properties, byte[] body) throws IOException {
				System.out.println("Recv:" + new String(body, "UTF-8"));
				channel.basicAck(envelope.getDeliveryTag(), false);
			}
		});
	}

}
  • 批量确认消费者
package com.adiao.rabbitmq.confirm;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.adiao.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class SendManyMsg {
	private static final String QUEUE_NAME="test_queue_confirm";
	public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
		Connection connection = ConnectionUtils.getConnection();
		
		Channel channel = connection.createChannel();
		
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		
		//单条开启
		channel.confirmSelect();
		
		String msg="This is Confirm";
		for (int i = 0; i < 10; i++) {
			if(i==5){
				int j=i/0;
			}
			channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
		}
		
		channel.waitForConfirmsOrDie();
		System.out.println("全部发送完成");
		channel.close();
		connection.close();
	}

}
  • 异步确认消费者 
    package com.adiao.rabbitmq.confirm;

import java.io.IOException;
import java.util.Date;
import java.util.concurrent.TimeoutException;

import com.adiao.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmListener;
import com.rabbitmq.client.Connection;

public class SendAsyn {

	private static final String QUEUE_NAME="test_queue_confirm";
	public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
		Connection connection = ConnectionUtils.getConnection();
		
		Channel channel = connection.createChannel();
		
		channel.queueDeclare(QUEUE_NAME, false, false, false, null);
		
		channel.confirmSelect();
		channel.addConfirmListener(new ConfirmListener() {
			
			public void handleNack(long deliveryTag, boolean multiple)
					throws IOException {
				System.out.println("未确认消息标识："+deliveryTag);
				
			}
			
			public void handleAck(long deliveryTag, boolean multiple)
					throws IOException {
				System.out.println(String.format("已确认消息标识:%d (%b)", deliveryTag,multiple));
			}
		});
		for (int i = 0; i <10; i++) {
			String msg=new Date().getTime()+ ":This is Asyn Confirm";
			System.out.println("Send:"+msg);
			channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
			Thread.sleep(1000);
			
		}
		
		
		
		channel.close();
		
		connection.close();
	}

}

     

Mr.ADiao
关注
专栏目录
动力节点RabbitMQ学习笔记，超详细的入门使用教程
DDDYSz的博客
12-28 1381
RabbitMQ是流行的开源消息队列系统，用erlang语言开发，RabbitMQ是AMQP(高级消息队列协议)的标准实现。采用该技术，我们可以实现异步处理、流量削峰、系统解耦。 RabbitMQ 整体是一个与其他中间件相同的模型，主要是负责接收、存储和转发消息。可以把消息传递的过程想想成快递：将一个快递送到快递公司，快递公司由快递员送到收件人的人中，RabbitMQ就类似于一个快递公司，也就是RabbitMQ的交换机模型。 什么是消息队列（MQ） 消息是在不同应用间传递的数据。这里的消息可以非常简单
RabbitMq学习笔记
weixin_43971312的博客
03-17 3489
RabbitMQ 1 简介 1.1 介绍 RabbitMQ是一个由erlang语言编写的、开源的、在AMQP基础上完整的、可复用的企业消息系统。支持多种语言，包括java、Python、ruby、PHP、C/C++等。 本质是个队列，FIFO 先入先出，只不过队列中存放的内容是message 而已，还是一种跨进程的通信机制，用于上下游传递消息。 (1)MQ：MQ是 message queue 的简称，是应用程序和应用程序之间通信的方法。 (2)AMQP：advanced message queuing.
RabbitMQ Work Queues 消息确认
十年饮冰，难凉热血
05-19 1958
RabbitMQ Work Queues 简介 Hello Word中只是简单介绍，下面开始重点分析 例如：当我们有复杂需求，我们需要提升效率，毕竟只有一个消费者难免处理不过来，就如官网中所提到的一样——在这篇教程中，将创建一个工作队列（Work Queue），它会发送一些耗时的任务给多个工作者（Worker）。 工作队列（又称：任务队列——Task Queues）是为了避免等待一些占用大量资源、...
RabbitMQ学习笔记[3]-RabbitMQ消息模型-work消息模型与消息自动确认机制
春盏
05-17 242
The main idea behind Work Queues (aka:Task Queues) is to avoid doing a resource-intensive task immediately and having to wait for it to complete. Instead we schedule the task to be done later. We encapsulate ataskas a message and send it to a queue. A ...
RabbitMQ的工作(即work)模式示例代码
小志的博客
04-22 397
1、RabbitMQ官网work模式的架构图 2、pom文件需要引入有关MQ的2个依赖包 <dependency> <groupId>org.springframework.amqp</groupId> <artifactId>spring-rabbit</artifactId> <version&gt...
rabbit mq Consumer Acknowledgements and Publisher Confirms 翻译
Venture758的专栏
09-14 356
原文地址 Consumer Acknowledgements and Publisher Confirms Overview This guide covers two related features related todata safety, consumer Acknowledgements and publisher confirms: Why acknowledgements exist Manual and automaticacknowledgement modes Ack...
RabbitMQ基础（2）——发布订阅/fanout模式 & topic模式 & rabbitmq回调确认 & 延迟队列（死信）设计
Arya的博客，专注后端领域
08-10 1961
1.rabbitmq队列方式的梳理，点对点，一对多； 2.发布订阅模式，交换机到消费者，以邮箱和手机验证码为例； 3.topic模式，根据规则决定发送给哪个队列； 4.rabbitmq回调确认，setConfirmCallback和setReturnsCallback； 5.死信队列，延迟队列，创建方法，正常---死信，设置延迟时间；
RabbitMQ学习笔记
06-22
**RabbitMQ学习笔记** RabbitMQ是一款广泛应用的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议，能够实现在分布式系统中可靠的消息传递。RabbitMQ的核心功能是作为一个消息代理，允许应用程序...
Spring学习笔记3之消息队列(rabbitmq)发送邮件功能
09-01
`acknowledge`属性控制确认机制，一般设置为`auto`，确保消息被正确处理后才会被删除。 5. **发送邮件**：在业务逻辑中，当用户注册时，将邮箱地址作为消息发送到RabbitMQ的队列。这通常通过调用`RabbitTemplate`的...
2022谷粒商城学习笔记（二十二）rabbitＭＱ学习
09-11 1150
61613, 61614 (STOMP协议端口)25672 (Erlang发现&集群端口)1883, 8883 (MQTT协议端口)5672, 5671 (AMQP端口)15672 (web管理后台端口)
RabbitMQ：第一章：6 种工作模式以及消息确认机制
最新发布
2401_83703951的博客
03-30 943
}System.out.println(“发送数据成功”);channel.close();connection.close();}}消费者一：import com.liao.rabbitmq.utils.RabbitConstant;import com.liao.rabbitmq.utils.RabbitUtils;import com.rabbitmq.client.*;import java.io.IOException;/***/public class ConsumerOne {public s
rabbitMQ的五种模型及消息确认机制
weixin_43937178的博客
01-02 1198
队列、交换机、生产者、消费者、虚拟主机之间的关系；不同的服务可以定义在不同的虚拟主机之中，不同的虚拟主机之间互不通信 1.HelloWorld 模型 生产者向队列中发送消息，消费者监听队列，消费消息； 当队列中的消息被拿走后，就会自动从队列中被删除； 存在的问题是：当消息被消费者拿走但并未被正常消费，但队列中的消息已被删除，此时可能会出现消息丢失现象。 2. work模型 当生产者生产消息的速度大于消费者消费消息的速度的时候 生产者向队列中发送消息 存在多个消费者平均消费消息 消息一旦被消费，即
springboot2.3.1整合RabbitMQ多种工作模式 发送确认，手动应答
热门推荐
胖虎儿的博客
07-15 1万+
springboot2.3.1整合RabbitMQ多种工作模式 发送确认，手动应答
RabbitMQ学习(四)——消息分发机制
Anumbrella
05-24 7980
在前面的一篇博文中，我们对RabbitMQ中的交换机有了大致的了解，同时结合Spring boot的实例，让我们对RabbitMQ的用法有了更清晰的认识。如果忘记了可以去复习一下，RabbitMQ学习(三)——探索交换机(Exchange)，结合SpringBoot实战。 今天我们将要对RabbitMQ的消息机制进行更详细的探究，在上一篇文章中其实也涉及到了该消息机制的问题。只是没有深入探究，今...
RabbitMQ之订阅模式与主题模式，消息确认机制
qflyIT的博客
06-10 1583
1.订阅模式 作用类似与微信公众号，你订阅了就可以接收到消息 解读: 1.一个生产者,多个消费者。 2.每一个消费者 都有自己的队列 3.生产者没有直搂把洧息发送到队列而是发到了交换机 转发器exchange 4.每个队列都要绑定到交换机上。 5.生产者发送的消息经过交换机到达臥列 就能实现一个消息到多个消费者消费 1.2分发模式 该模式下，生产者发送消息，多个消费者通过他们对应的队列获得消息，但是所获得的消息是一样的，不能指定将哪个消息给那个队列 创建一个生产者 public class send {
RabbitMQ 使用fanout交换机发送和接收消息
m0_50163856的博客
09-03 464
依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.13.0</version> </dependency> public class MyRabbitFactory { public static Connection getConnect
RabbitMQ消息监听（多种模式-fanout/topic）
chuiqueyu5654的博客
09-12 4003
1.rabbitmq消息监听，兼容多种模式的消息，fanout/topic等模式 MQ消息配置监听： package com.test.ddyin.conf; import java.util.HashMap; import java.util.List; import java.uti...
RibbitMQ 实战教程
Hbernet的博客
08-21 565
dfghjkl;'
11_RabbitMQ之消息确认机制
架构师的成长之路的博客
03-19 1468
11_RabbitMQ之消息确认机制更多干货分布式实战（干货）spring cloud 实战（干货）mybatis 实战（干货）spring boot 实战（干货）React 入门实战（干货）构建中小型互联网企业架构（干货）python 学习持续更新例子代码地址https://github.com/csy512889371/learndemo/tree/master/ctoedu-rabitmq概...
RabbitMQ学习笔记详细解析
资源摘要信息:"rabbitmq学习笔记" 知识点: 1. RabbitMQ简介: RabbitMQ是一个开源的消息代理软件，即消息中间件。它是用Erlang编程语言开发的，并且基于高级消息队列协议（AMQP）标准。RabbitMQ常被用于构建分布式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值