RabbitMQ的基本使用

最新推荐文章于 2024-03-19 09:17:23 发布
最新推荐文章于 2024-03-19 09:17:23 发布
阅读量257 收藏
点赞数 1
分类专栏： java 文章标签： rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42998267/article/details/104649926
版权

docker安装RabbitMQ

#先拉取下来
docker pull rabbitmq
#给rabbitmq创建容器并启动
docker run -d  -p 5671:5671 -p 5672:5672  -p 15672:15672 -p 15671:15671  -p 25672:25672  -v /data/rabbitmq-data/:/var/rabbitmq/lib  --name rabbitmq b8956a8129ef
#进入rabbitmq
docker exec -it rabbitmq sh
#运行
rabbitmq-plugins enable rabbitmq_management

#浏览器访问：http://ip地址:15672
#用户名密码:guest

添加用户

添加用户界面

Virtual Hosts管理 就相当于数据库
添加数据库
数据库权限

java连接RabbitMQ

引入maven依赖

<!-- 引入队列依赖 -->
<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>

<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
</dependency>
  • 生产者
  • 队列 rabbitmq
  • 消费者

简单队列（simple queue）

获取连接

public class ConnectionUtils {
//获取mq的连接
    public static Connection getConnection() throws IOException, TimeoutException {
//        定义一个连接工厂
        ConnectionFactory factory=new ConnectionFactory();
//        设置服务地址
        factory.setHost("39.107.221.63");
//        AMQP 5672
        factory.setPort(5672);
//        vhost
        factory.setVirtualHost("/vhost_hzy");
        factory.setUsername("user_hzy");
        factory.setPassword("root");
        return factory.newConnection();
    }
}

生产者

//生产者生产消息
public class Send {
    private static final String QUEUE_NAME="test_simple_queue";
    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="hello simple !";
//        负责生产消息
        channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
        System.out.println("--send msg:"+msg);
        channel.close();
        connection.close();
    }
}

消费者

//消费者获取消息
public class Recv {
    private static final String QUEUE_NAME="test_simple_queue";
    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);
//        定义消费者
        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("new api recv:" + msg);
            }
        };
//        监听队列
        channel.basicConsume(QUEUE_NAME,true,consumer);
/** 不推荐
//        定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
//        监听队列
        channel.basicConsume(QUEUE_NAME,true,consumer);
        while(true){
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String msgString=new String(delivery.getBody());
            System.out.println("{recv} msg:"+msgString);
        }
 */
    }
}

简单队列的不足
耦合性高，生产者11对应消费者(如果多个消费者消费队列中消息，就不行了；队列名变更 必须同时变更)

Work queues 工作队列

P------Queue------C1,C2

(轮询方式)
先创建一个获取连接的方法(简单队列中有)
生产者

public class Send {
    /**
     * P------Queue------C1,C2
     * */
    private static final String QUEUE_NAME="test_work_queue";
    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);
        for (int i = 0; i < 50; i++) {
            String msg="hello"+i;
            System.out.println("{work send}:"+msg);
            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            try {
                Thread.sleep(i*20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        channel.close();
        connection.close();
    }
}

消费者1

public class Recv1 {
    private static final String QUEUE_NAME="test_work_queue";
    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);
        Consumer 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(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[1] done");
                }
            }
        };
        boolean autoAck=true;
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);
    }
}

消费者2
复制消费者1代码进行修改

(公平分发 fair dipatch)

使用公平分发，必须关闭自动应答ack，改成手动

在生产者中生产消息之前加上

//        使用公平分发      每个消费者发送确认消息之前，消息队列不发送下一个消息到消费者   1次只处理一个消息
        int prefetchCount=1;
        channel.basicQos(prefetchCount);

消费者1

public class Recv1 {
    private static final String QUEUE_NAME="test_work_queue";
    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.basicQos(1);//保证一次只分发一个

        Consumer 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(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[1] done");
// 公平分发                   手动回复消息
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
// 公平分发                  自动应答改为false
        boolean autoAck=true;
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);
    }
}

消费者2同理

消息应答与消息持久化

  1. 消息应答

boolean autoAck=true;(自动确认模式)一旦rabbitmq将消息分发给消费者，就会从内存中删除
这种情况下，如果杀死正在执行的消费者，就会丢失正在处理的消息。
boolean autoAck=false;(手动确认模式)，如果有一个消费者挂掉，就会交付给其他消费者，rabbitmq支持消息应答，消费者发送一个消息应答，告诉rabbitmq这个消息我处理完了，然后rabbitmq就删除内存中的消息
消息应答默认是false

  1. 消息持久化

//声明队列
boolean durable=true;
channel.queueDeclare(QUEUE_NAME,durable,false,false,null);
我们将程序中的boolean durable改成true，就实现了持久化，注意：如果更改已存在的队列会报错！！！
注意：rabbitmq不允许重新定义（不同参数）一个已存在的队列
解决方法：更改队列名或者删除已存在的队列，重新创建
持久化位置

订阅模式publist/subscribe

发布订阅

  1. 一个生产者，多个消费者
  2. 每一个消费者都有自己的队列
  3. 生产者没有直接把消息发送到队列，而是发到了交换机 转发器 exchange
  4. 每个队列都要绑定到交换机上
  5. 生产者发送的消息 经过交换机 到达队列 就能实现 一个消息被多个消费者消费

注册->邮件->短信…
生产者

public class Send {
    private static final String EXCHANGE_NAME="test_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection= ConnectionUtils.getConnection();
        Channel channel=connection.createChannel();
//        声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");//分类
//        发送消息
        String msg="hello ps";
        channel.basicPublish(EXCHANGE_NAME,"",null,msg.getBytes());
        System.out.println("Send :"+msg);
        channel.close();
        connection.close();
    }
}

注意：交换机没有存储能力，只有队列有存储能力！
消费者1

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 connection= ConnectionUtils.getConnection();
        final Channel channel=connection.createChannel();
//        队列声明
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
//        绑定队列到交换机
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");
        //公平分发
        channel.basicQos(1);//保证一次只分发一个

        Consumer 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(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[1] done");
// 公平分发                   手动回复消息
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
// 公平分发                  自动应答改为false
        boolean autoAck=false;
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);
    }
}

消费者2同上

路由模式

Exchange(交换机 转发器)
一方面是接收生产者的消息，另一方面是向队列推送消息
匿名转发
Fanout(不处理路由键)
Direct(处理路由键)

生产者

public class Send {
    private static final String EXCHANGE_NAME="test_exchange_direct";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection= ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
//        exchange
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");
        String msg="hello direct!";
        String routingKey="info";//发送的key,绑定这人key的会收到
        channel.basicPublish(EXCHANGE_NAME,routingKey,null,msg.getBytes());
        System.out.println("[send]:"+msg);
        channel.close();
        connection.close();
    }
}

消费者1

public class Recv1 {
    private static final String EXCHANGE_NAME="test_exchange_direct";
    private static final String QUEUE_NAME="test_queue_direct_1";
    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.basicQos(1);
//        绑定key,消费生产者中的key
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"error");
        Consumer 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("[Recv1]:"+msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[done1]");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=false;
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);

    }
}

在消费者2中会绑定多个key
`// 绑定多个key，哪个key发送消息，就接受哪个key的消息

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

主题模式

Topic exchange
将路由键和某模式匹配
#匹配一个或者多个
*匹配一个

生产者

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();
//        exchange
        channel.exchangeDeclare(EXCHANGE_NAME,"topic");
        String msgString="商品....";
        channel.basicPublish(EXCHANGE_NAME,"goods.upd",null,msgString.getBytes());
        System.out.println("----send "+msgString);
        channel.close();
        connection.close();
    }
}

消费者和上面的订阅模式基本一样
区别：将订阅模式中的key改为

channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"goods.#");

Rabbitmq的消息确认机制

问题：生产者将消息发送出去之后，消息到底有没有到达rabbitmq服务器，默认的情况是不知道的；
两种方式解决：

  • AMQP实现了事务机制

  • Confirm模式
    AMQP事务机制
    txSelect txCommit txRollback

  • txSelect 用于将当前channel设置成transation模式

  • txCommit 用于提交事务

  • txRollback 用于回滚事务
    生产者

public class TxSend {
    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 tx_msg="hello tx message";
        try {
            channel.txSelect();
            channel.basicPublish("",QUEUE_NAME,null,tx_msg.getBytes());
            channel.txCommit();
        }catch (Exception e){
            channel.txRollback();
            System.out.println("执行了事务回滚！");
        }
    }
}

消费者

public class TxRecv {
    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, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("[recv[tx] msg]"+new String(body,"utf-8"));
            }
        });
    }
}

Confirm模式

Confirm模式最大的好处在于他是异步
注意:队列不能重复设置AMQP事务和Confirm事务

Confirm单条消息
生产者

public class Send1 {
    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);
        String tx_msg="hello confirm message";
//        设置confirm事务
        channel.confirmSelect();
        channel.basicPublish("",QUEUE_NAME,null,tx_msg.getBytes());
//        确认发送消息
        if(!channel.waitForConfirms()){
//        如果失败
            System.out.println("message send failed");
        }else{
            System.out.println("message send ok");
        }
        channel.close();
        connection.close();
    }
}

消费者同AMQP事务
Confirm多条消息

同时发送一批量的消息

public class Send2 {
    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);
        String tx_msg="hello confirm message barch";
//        设置confirm事务
        channel.confirmSelect();
        for (int i = 0; i < 10; i++) {
            channel.basicPublish("",QUEUE_NAME,null,tx_msg.getBytes());
        }
//        确认发送消息
        if(!channel.waitForConfirms()){
//        如果失败
            System.out.println("message send failed");
        }else{
            System.out.println("message send ok");
        }
        channel.close();
        connection.close();
    }
}

异步Confirm模式

public class Send3 {
    private static final String QUEUE_NAME="test_queue_confirm3";
    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);
//        生产者调用confirmSelect将channel设置为confirm模式注意
        final SortedSet<Long> confirmSet= Collections.synchronizedSortedSet(new TreeSet<Long>());
//        通道添加监听
        channel.addConfirmListener(new ConfirmListener() {
//            没有问题的handleAck
            @Override
            public void handleAck(long l, boolean b) throws IOException {
                if(b){
                    System.out.println("---handleAck---true");
                    confirmSet.headSet(l+1).clear();
                }else{
                    System.out.println("---handleAck---false");
                    confirmSet.remove(l);
                }
            }
            @Override
            public void handleNack(long l, boolean b) throws IOException {
                if(b){
                    System.out.println("---handleAck---true");
                    confirmSet.headSet(l+1).clear();
                }else{
                    System.out.println("---handleAck---false");
                    confirmSet.remove(l);
                }
            }
        });
        String msgStr="message str";
        while (true){
            long seqNo=channel.getNextPublishSeqNo();
            channel.basicPublish("",QUEUE_NAME,null,msgStr.getBytes());
            confirmSet.add(seqNo);
        }
    }
}

spring整合rabbitmq
spring整合rabbitmq

<!-- 引入队列依赖 -->
    <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>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>5.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.0.0.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.0.0.RELEASE</version>
    </dependency>
    <!-- RabbitMQ -->
    <dependency>
      　　<groupId>org.springframework.amqp</groupId>
      　　<artifactId>spring-rabbit</artifactId>
      　　<version>1.7.5.RELEASE</version>
    </dependency>

xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/rabbit
    http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd" >
<!--    定义RabbitMQ的连接工厂-->
<rabbit:connection-factory id="connectionFactory" host="39.107.221.63" port="5672" username="guest" password="guest" virtual-host="/vhost_hzy"/>
<!--    定义Rabbit模板，指定连接工厂以及定义exchange-->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory" exchange="fanoutExchange"/>
<!--    MQ的管理，包括队列、交换器声明等-->
    <rabbit:admin connection-factory="connectionFactory"/>
<!--    定义队列，自动声明-->
    <rabbit:queue name="myQueue" durable="true"/>
<!--    定义交换器，自动声明-->
    <rabbit:fanout-exchange name="fanoutExchange">
        <rabbit:bindings>
            <rabbit:binding queue="myQueue"/>
        </rabbit:bindings>
    </rabbit:fanout-exchange>
<!--    队列监听-->
    <rabbit:listener-container connection-factory="connectionFactory" acknowledge="auto">
        <rabbit:listener ref="foo" method="listen" queue-names="myQueue"/>
    </rabbit:listener-container>
<!--    消费者-->
    <bean id="foo" class="com.hzy.rabbitmq.spring.MyConsumer"/>
</beans>

生产者

        AbstractApplicationContext applicationContext=new ClassPathXmlApplicationContext("classpath:spring-context.xml");
//        RabbitMQ模板
        RabbitTemplate template=applicationContext.getBean(RabbitTemplate.class);
//        发送消息
        template.convertAndSend("Hello-World!");
        Thread.sleep(1000);
        applicationContext.destroy();//容器销毁

消费者

    public void listen(String foo){
        System.out.println("消费者："+foo);
    }

应用场景

在用户进行增加，删除，修改时，及时更改缓存中的数据！
当用户在数据库中增加，删除，修改时，告诉缓存(如redis)该更新数据了，然后进行更新！

rabbitmq死信队列详解与使用
congge
08-28 14万+
什么是死信队列 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信，自然就有了死信队列； 以上是个人的通俗解释，专业术语解释的比...
RabbitMQ六种队列模式-简单队列模式
luoshisiji的专栏
11-23 531
RabbitMQ之简单队列模式
SpringBoot中 RabbitMQ 动态添加Queue和Listener
Damien_J_Scott的博客
08-16 2214
之前项目中涉及了动态配置Queue name的需求，但是解决了一直没有记录，今天看到了顺便记录下。首先声明一个Queue的bean，这里面你就可以拼接你想要的queue的name。然后就是写Listener了，注册监听该Queue。这里True的意思是一个持久的Queue。
RabbitMQ入门（二）
博客
02-18 1880
在上一篇博客,笔者简单的介绍了一些RabbitMQ相关的内容,在这一篇博客会根据RabbitMQ官网的入门介绍,结合笔者自身的理解更深入的在代码方面介绍RabbitMQ的入门使用，。同样,这篇博客主要的目的也是整理记录自己的学习笔记,加深自己对RabbitMQ的使用与理解。 RabbitMQ入门（一） RabbitMQ入门（二） RabbitMQ入门（三） 目录 1.入门 创建消息生产...
RabbitMq------初级+高级（一）
weixin_54406708的博客
08-02 2685
基于spring-boot-AMQP来对rabbitmq进行消息的异步发送，以及对应的队列。
队列（queue）
m0_56246173的博客
11-08 807
然而循环的概念又从何而来呢，很显然根据上面移动头指针的方式，将会浪费前面的内存，因此我们将队头和队尾连接起来，设置成一个环形，这样也就避免了浪费，连起来也就得到了所谓的循环概念。假如只是用单链表去实现链式队列，则队尾插入（尾插），队头出（头删），这时，我们会要求头删的时间复杂度O(1),尾插的时间复杂度为仍为O(1),但是如果是上述单链表，找到尾结点需要遍历整个单链表，尾插的时间复杂度为O(n),很显然不符合要求为此做一修改，但是在这里，我们用顺序表实现的不叫顺序队列，而叫循环队列。
Python三方库：RabbitMQ基本使用
m0_61653001的博客
07-08 6001
Python三方库：RabbitMQ基本使用
RabbitMQ基本概念和使用
01-30
RabbitMQ是一个消息代理，核心原理：发送消息，接收消息...首先通过一个非常简单的”helloworld“例子介绍如何使用RabbitMQ，然后再介绍其涉及的基本概念并对交换机和队列多做点介绍。本例非常简单——发送一个消息”h
【RabbitMQ | 第二篇】RabbitMQ基本使用
最新发布
踢桃的成长之路
03-19 1465
RabbitMQ基本使用篇文章介绍了RabbitMQ的核心概念（生产者消费者、交换机、消息队列、消息中间件的服务节点、以及交换机类型：fanout广播、direct:bindingdkey与routingkey相同）、topic：更灵活的匹配规则、AMQP介绍、以及死信队列的介绍，导致死信消息的原因（TTL已到、消息队列已满、消息被拒）
RabbitMQ：Queue的介绍和使用
编程学习者的博客
05-13 7475
1.声明 当前内容用于本人学习和使用当前的Queue,当前内容为RabbitMQ中对Queue的介绍 当前内容来源：RabbitMQ中的Queue 2.Queue的官方介绍 首先先分析以下前面的Queue的使用，其实这个东西就是一个队列，一个存储消息的队列，并且可以持久化，而且这个队列中的消息可以被消费，如果出现死信则是死信队列，死信队列也是可以被处理的 接下来就是官方介绍 Queues in the AMQP 0-9-1 model are very similar to queues in other
RabbitMQ之Exchange、Queue参数详解
Data & Analysis
08-05 1684
1.先来介绍RabbitMQ中的成员 Producer(生产者)： 将消息发送到Exchange Exchange(交换器)：将从生产者接收到的消息路由到Queue Queue(队列)：存放供消费者消费的消息 BindingKey(绑定键)：建立Exchange与Queue之间的关系（个人看作是一种规则，也就是Exchange将什么样的消息路由到Queue） RoutingKey(路由键)：Producer发送消息与路由键给Exchange，Exchange将判断RoutingKey是否符合Bin
RabbitMQ 的队列 queues 名称为空的解决方法
tang_jian_dong的博客
11-06 2926
今天碰到很奇怪的问题， rabbitmq的队列名称居然为空了， 队列中积累了两百多万的数据， 快把mq搞蹦了， 没有队列名称就删除不了，也清空不了消息， 在服务器节点上： rabbitmqctl list_queues 查询队列也超时 这个时候就想起来： 只能把这个队列所在的virtual host 虚拟空间干掉， 不然没办法删除了。 步骤： 1 备份 该队列的 virtual host 参考以下任一方式导出包括全部Vhost的RabbitMQ集群元数据文件。 RabbitMQ...
RabbitMQ使用说明，配置属性说明
xgw的专栏
11-09 6558
简介 介绍 RabbitMQ 是一个由 erlang 开发的基于 AMQP（Advanced Message Queue）协议的开源实现。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面都非常的优秀，是当前最主流的消息中间件之一。RabbitMQ 官网：http://www.rabbitmq.com AMQP AMQP 是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，同样，消息使用者也不用知道发送者的存在。AMQP
SpringBoot 整合 ActiveMQ，多个queue和多个topic实现，及前端VUE使用Stompjs接收
erf_1012的专栏
06-05 4867
参考自：https://www.cnblogs.com/yufeng218/p/11509486.html 一、ActiveMQ简介 1). ActiveMQ ActiveMQ是Apache所提供的一个开源的消息系统，完全采用Java来实现，因此，它能很好地支持J2EE提出的JMS（Java Message Service,即Java消息服务）规范。JMS是一组Java应用程序接口，它提供消息的创建、发送、读取等一系列服务。JMS提供了一组公共应用程序接口和响应的语法，类似于Java数据库的统一访问.
RabbitMQ系列（三）RabbitMQ进阶-Queue队列特性 (一)简单队列
流浪的喵的博客
06-18 2388
RabbitMQ Exchange和Queue队列 RabbitMQ 任务分发
RabbitMQ实战篇4-队列(queue)
朱哲的博客
06-10 2818
队列在声明（declare）后才能被使用。如果一个队列尚不存在，声明一个队列会创建它。如果声明的队列已经存在，并且属性完全相同，那么此次声明不会对原有队列产生任何影响。如果声明中的属性与已存队列的属性存在差异，那么一个错误代码为406的通道级异常就会被抛出。队列的属性队列中存储着即将被消费掉的信息，它有如下属性：1、名称2、持久性（消息代理重启后，队列依旧存在）3、独享（只被一个连接（connec...
queue的常见用法详解
热门推荐
分享包括但不限于计算机基础知识、数据结构与算法、Golang技术栈。年与时驰，意与日去，遂成枯落，多不接世，悲守穷庐，将复何及！
09-04 2万+
queue翻译为队列，是一个先进先出的容器，要使用queue，应先添加头文件#include<queue>，并在头文件下面加上“using namespace std;”。 1.queue的定义： 定义的写法和其他STL容器相同， typename可以是任意基本数据类型或容器： queue<typename> name; 2. queue容器内元素的访问： ...
数据结构 - 队列
Name_Larry
04-03 469
队列分为链式队列和静态队列。 静态队列一般用数组来实现，但此时的队列必须是循环队列，否则会造成巨大的内存浪费。 链式队列是用链表来实现队列的。 循环队列 循环队列需要2个参数，front 和 rear 。 队列初始化时，front 和 rear 都为零。 当队列不为空时，front 指向队列的第一个元素，rear 指向队列最后一个元素的下一个位置。 当队列为空时，fr
RabbitMQ：源码分析之Queue类
王小二(海阔天空)
01-17 1769
RabbitMQ：源码分析之Queue 一、源码如下： package org.springframework.amqp.core; import java.util.Map; import org.springframework.util.Assert; public class Queue extends AbstractDeclarable { private final Stri...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值