rabbitMq入门教程

已于 2022-05-12 11:39:47 修改
阅读量1.8k 收藏
点赞数
分类专栏： 新手入门教程 文章标签： rabbitmq 分布式 java
于 2021-12-15 11:08:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tttalk/article/details/121931244
版权

文章目录

一、下载安装

1.rabbitMq的运行需要erlang环境。
erlang官网下载:http://erlang.org/download/otp_win64_24.1.exe (24.1为版本号)。
一直点下一步即可，最好不要修改安装目录，安装后，添加环境变量Path：C:\Program Files\erl-24.1\bin
验证：在cmd输入 erl -v 可以查看erlang版本

2.rabbitMq官网下载：https://www.rabbitmq.com/install-windows.html
也是一直点下一步安装，可以修改安装目录，比如我的安装目录是 D:\Tools\rabbitMq\install\rabbitmq_server-3.9.10。
cmd 进入sbin目录 cd /d D:\Tools\rabbitMq\install\rabbitmq_server-3.9.10\sbin，
然后启动插件rabbitmq-plugins enable rabbitmq_management。
登录：http://localhost:15672/ 输入guest/guest。可以看到登录成功后的界面。
在这里插入图片描述
在刚刚的cmd界面，添加admin用户：rabbitmqctl add_user admin admin
设置管理员权限：rabbitmqctl set_user_tags admin administrator
再次登录：http://localhost:15672/ admin/admin 点击admin，
右侧选择Visual Hosts,添加当前用户的visual hosts:v_host1,后面会用到
在这里插入图片描述

二、在java中使用rabbitMq

使用rabbitMq前一般要先了解下常见的queue（也可以先学习rabbitMq，后面再了解），可参考：https://blog.csdn.net/tttalk/article/details/121947982
1.pom.xml引入相关配置
如果你是springBoot项目，可以用下面的配置：

<dependency>
    <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-amqp</artifactId>
 </dependency>

如果不是就用这个：

<dependency>
     <groupId>com.rabbitmq</groupId>
      <artifactId>amqp-client</artifactId>
      <version>4.10.0</version>
  </dependency>

2.创建连接文件ConnectionUtil.java

package com.example.springb_web.utils.rabbitMq;

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


public class ConnectionUtil {

    public static Connection getConnection() throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        //默认端口,若需要修改，需要配置文件rabbitmq.config(需要自己创建，路径为etc/rabbitmq/rabbitmq.cnfig)
        factory.setPort(5672);
        //默认用户guest，其下的默认vhost为/,登录admin后，添加v_host1
        factory.setVirtualHost("v_host1");
        factory.setUsername("admin");
        factory.setPassword("admin");
        Connection connection = factory.newConnection();
        return  connection;
    }
}

3.生产者测试主类，含简单模式、订阅模式和发布订阅模式，里面注释写的满详细的。

package com.example.springb_web.utils.rabbitMq;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import org.unbescape.xml.XmlEscape;

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

public class MqProducerTest {

    //简单模式-应用场景：聊天
    private final static String QUEUE_NAME_SIMPLE = "queue_test_simple";
    //work模式-资源竞争，应用场景：红包、电商订单、资源调度
    private final static String QUEUE_NAME_WORK = "queue_test_work";
    //发布订阅模式-共享资源，应用场景：邮件群发、群聊、广播
    private final static String QUEUE_NAME_SUBSCRIBE = "queue_test_subscribe";
    private final static String EXCHANGE_NAME_SUBSCRIBE = "exchange_name_subscribe";
    //路由routing模式，路由模式和topic模式都与发布订阅模式类似，主要是交换机类型不一样，fanout改成direct或topic
    private final static String QUEUE_NAME_ROUTING = "queue_test_routing";
    //topic模式-路由模式的一种
    private final static String QUEUE_NAME_TOPIC = "queue_test_topic";
    //rpc模式
    private final static String QUEUE_NAME_RPC = "queue_test_rpc";

    public static void main(String[] args)  {
        Connection connection = null;
        Channel channel = null;
        try {
            connection = ConnectionUtil.getConnection();
            channel = connection.createChannel();

            String msg = "thank you,next";
            //简单模式
            channel.queueDeclare(QUEUE_NAME_SIMPLE,false,false,false,null);
            channel.basicPublish("",QUEUE_NAME_SIMPLE,null, msg.getBytes());
            
            //work模式  三个参数代表 durable, exclusive, autoDelete
            //durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
            // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
            // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
            channel.queueDeclare(QUEUE_NAME_WORK,true,false,false,null);
            for(int i = 0; i < 100; i++) {
                channel.basicPublish("",QUEUE_NAME_WORK,null, (msg+i).getBytes());
                //每0.5s发送一条，设定comsumer1几乎无延迟接受，consumer2每1.5秒接受一次，理论上consumer1接受的消息数是consumer2的三倍
                //试过将consumer2间隔设定为1s,结果几乎是平均分配,一条给consumer1,一条给cunsumer2。间隔时间长一些才能看出区别
                Thread.sleep(500);
            }
            
            //发布订阅模式
            //exchange类型之Fanout:消息会分配到所有队列
            channel.exchangeDeclare(EXCHANGE_NAME_SUBSCRIBE, "fanout");
            channel.basicPublish(EXCHANGE_NAME_SUBSCRIBE,"",null, msg.getBytes());

            channel.close();
            connection.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

4.消费者代码，其中MyConsumerTest、MyConsumerTest2是测试主类，MessageConsumer、MessageConsumer2主要是处理应答的。这里我用的代码版本还是比较新的，网上很多教程都用了过时的方法，在4.0中(QueueingConsumer)已经废弃了,所以我这里用了MessageConsumer/MessageConsumer2来替代。

package com.example.springb_web.utils.rabbitMq;

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

public class MyConsumerTest {

    //简单模式-应用场景：聊天
    private final static String QUEUE_NAME_SIMPLE = "queue_test_simple";
    //work模式-资源竞争，应用场景：红包、电商订单、资源调度
    private final static String QUEUE_NAME_WORK = "queue_test_work";
    //发布订阅模式-共享资源，应用场景：邮件群发、群聊、广播
    private final static String QUEUE_NAME_SUBSCRIBE = "queue_test_subscribe";
    private final static String EXCHANGE_NAME_SUBSCRIBE = "exchange_name_subscribe";
    //路由routing模式，路由模式和topic模式都与发布订阅模式类似，主要是交换机类型不一样，fanout改成direct或topic
    private final static String QUEUE_NAME_ROUTING = "queue_test_routing";
    //topic模式-路由模式的一种
    private final static String QUEUE_NAME_TOPIC = "queue_test_topic";
    //rpc模式
    private final static String QUEUE_NAME_RPC = "queue_test_rpc";

    public static void main(String[] args)  {
        Connection connection = null;
        Channel channel = null;
        try {
            connection = ConnectionUtil.getConnection();
            channel = connection.createChannel();
            channel.queueDeclare(QUEUE_NAME_SIMPLE,false,false,false,null);

            //自定义消费者类
            //简单模式
            MessageConsumer simpleConsumer = new MessageConsumer(channel);
            channel.basicConsume(QUEUE_NAME_SIMPLE, true, simpleConsumer);
            
            //work模式
            Consumer workConsumer = new MessageConsumer(channel);
            //使用basicQos( prefetchCount = 1)方法，来限制RabbitMQ只发不超过1条的消息给同一个消费者。当消息处理完毕后，有了反馈，才会进行第二次发送。
            //还有一点需要注意，使用公平分发，必须关闭自动应答，改为手动应答。
            channel.basicQos(1);
            channel.basicConsume(QUEUE_NAME_WORK, false, workConsumer);
            
            //发布订阅模式
            Consumer subscribeConsumer = new MessageConsumer(channel);
            // 绑定队列到交换机--需要在v_host1下新建exchange--exchange_name_subscribe和queue--queue_test_subscribe
            channel.queueBind(QUEUE_NAME_SUBSCRIBE, EXCHANGE_NAME_SUBSCRIBE, "");
            channel.basicQos(1);
            channel.basicConsume(QUEUE_NAME_SUBSCRIBE, false, subscribeConsumer);

            //老版本(3.0)代码，QueueingConsumer(4.0已废除)内部用LinkedBlockingQueue来存放消息的内容，而LinkedBlockingQueue：一个由链表结构组成的有界队列 ，
            // 照先进先出的顺序进行排序，未指定长度的话，默认 此队列的长度为Integer.MAX_VALUE，那么问题来了，如果生产者的速度远远大于消费者的速度，
            // 也许没等到队列阻塞的条件产生（长度达到Integer.MAX_VALUE）内存就完蛋了，
            // 在老的版本你可以通过设置 rabbitmq的prefetch属性channel.basicQos(prefetch)来处理这个问题如果不设置可能出现内存问题
             /* // 定义队列的消费者
            QueueingConsumer consumer = new QueueingConsumer(channel);
            // 监听队列
            channel.basicConsume(QUEUE_NAME, true, consumer);
            // 获取消息
            while (true) {
                QueueingConsumer.Delivery delivery = consumer.nextDelivery();
                String message = new String(delivery.getBody());
                System.out.println(" [x] Received '" + message + "'");
            }*/

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}


package com.example.springb_web.utils.rabbitMq;

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

public class MyConsumerTest2 {

    //简单模式-应用场景：聊天
    private final static String QUEUE_NAME_SIMPLE = "queue_test_simple";
    //work模式-资源竞争，应用场景：红包、电商订单、资源调度
    private final static String QUEUE_NAME_WORK = "queue_test_work";
    //发布订阅模式-共享资源，生产者没有将消息直接发送到队列，而是发送到了交换机,应用场景：邮件群发、群聊、广播
    private final static String QUEUE_NAME_SUBSCRIBE2 = "queue_test_subscribe2";
    private final static String EXCHANGE_NAME_SUBSCRIBE = "exchange_name_subscribe";
    //路由routing模式，路由模式和topic模式都与发布订阅模式类似，主要是交换机类型不一样，fanout改成direct或topic
    private final static String QUEUE_NAME_ROUTING = "queue_test_routing";
    //topic模式-路由模式的一种
    private final static String QUEUE_NAME_TOPIC = "queue_test_topic";
    //rpc模式
    private final static String QUEUE_NAME_RPC = "queue_test_rpc";

    public static void main(String[] args)  {
        Connection connection = null;
        Channel channel = null;
        try {
            connection = ConnectionUtil.getConnection();
            channel = connection.createChannel();
            channel.queueDeclare(QUEUE_NAME_SIMPLE,false,false,false,null);

            //自定义消费者类
            //简单模式
            MessageConsumer2 simpleConsumer = new MessageConsumer2(channel);
            //监听队列，false表示手动返回完成状态，true表示自动
            channel.basicConsume(QUEUE_NAME_SIMPLE, true, simpleConsumer);
            
            //work模式，若不限制basicQos和关闭自动应答，则会消息会平均分配给两个consumer
            MessageConsumer2 workConsumer = new MessageConsumer2(channel);
            //使用basicQos( prefetchCount = 1)方法，来限制RabbitMQ只发不超过1条的消息给同一个消费者。当消息处理完毕后，有了反馈，才会进行第二次发送。
            //还有一点需要注意，使用公平分发，必须关闭自动应答，改为手动应答。
            channel.basicQos(1);
            channel.basicConsume(QUEUE_NAME_WORK, false, workConsumer);
            
            //发布订阅模式
            Consumer subscribeConsumer = new MessageConsumer(channel);
            // 绑定队列到交换机,！！！注意这里队列不能跟consumer1一样，不然同一队列只有一个能消费。
            // 绑定队列到交换机--需要在v_host1下新建exchange--exchange_name_subscribe和queue--queue_test_subscribe2
            channel.queueBind(QUEUE_NAME_SUBSCRIBE2, EXCHANGE_NAME_SUBSCRIBE, "");
            channel.basicQos(1);
            channel.basicConsume(QUEUE_NAME_SUBSCRIBE2, false, subscribeConsumer);
            //路由模式和topic模式都与发布订阅模式类似，生产者中fanout改成direct或topic
            //老版本(3.0)代码，QueueingConsumer(4.0已废除)内部用LinkedBlockingQueue来存放消息的内容，而LinkedBlockingQueue：一个由链表结构组成的有界队列 ，
            // 照先进先出的顺序进行排序，未指定长度的话，默认 此队列的长度为Integer.MAX_VALUE，那么问题来了，如果生产者的速度远远大于消费者的速度，
            // 也许没等到队列阻塞的条件产生（长度达到Integer.MAX_VALUE）内存就完蛋了，
            // 在老的版本你可以通过设置 rabbitmq的prefetch属性channel.basicQos(prefetch)来处理这个问题如果不设置可能出现内存问题
             /* // 定义队列的消费者
            QueueingConsumer consumer = new QueueingConsumer(channel);
            // 监听队列
            channel.basicConsume(QUEUE_NAME, true, consumer);
            // 获取消息
            while (true) {
                QueueingConsumer.Delivery delivery = consumer.nextDelivery();
                String message = new String(delivery.getBody());
                System.out.println(" [x] Received '" + message + "'");
            }*/

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}


package com.example.springb_web.utils.rabbitMq;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

import java.io.IOException;

public class MessageConsumer extends DefaultConsumer {
    Channel sendACKChannel;
    public MessageConsumer(Channel channel){
        super(channel);
        sendACKChannel = channel;
    }
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        //TODO sometingn
        String msg = new String(body);
        // 返回确认状态，自动确认模式时需要注释掉
        sendACKChannel.basicAck(envelope.getDeliveryTag(),false);
        System.out.println(" [x] Received '" + msg + "'");
    }
}


package com.example.springb_web.utils.rabbitMq;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

import java.io.IOException;

public class MessageConsumer2 extends DefaultConsumer {
    //应答时会用到
    Channel sendACKChannel;
    public MessageConsumer2(Channel channel){
        super(channel);
        sendACKChannel = channel;
    }
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        //TODO sometingn

        try {
            String msg = new String(body);

            //为了区分和cosumer1的消费速率
            Thread.sleep(1500);
            // 返回确认状态，自动确认模式时需要注释掉
            sendACKChannel.basicAck(envelope.getDeliveryTag(),false);
            System.out.println(" [x] Received '" + msg + "'");

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

5.测试步骤
(1)简单模式，应用场景：聊天
在此之前先新建一些队列，用于接收数据。我这里在v_host1下建立了queue_test_simple、queue_test_work、queue_test_subscribe、queue_test_subscribe2这四个，和代码中的要能对于上即可。
在这里插入图片描述

如图所示，调试的时候把MyConsumerTest和MqProducerTest的work模式以下的代码都注释掉，这样方便调试。
在这里插入图片描述先开启MyConsumerTest，右键MyConsumerTest.java,选择debug运行
在这里插入图片描述
同理再开启MqProducerTest，可以看到consumer输出如下
在这里插入图片描述
(2)work模式-资源竞争，应用场景：红包、电商订单、资源调度
同理也是注释掉简单模式和发布订阅模式的代码，然后按顺序重新启动消费者1，消费者2和生产者。
在这里插入图片描述
可以看到输出如下：
在这里插入图片描述

在这里插入图片描述
能看到消费者1和消费者2竞争资源，且平均消费者2消费一条，消费者1可以消费3条，这是因为给消费者设置的消费速率不同，生产者每0.5s发送一条，设定comsumer1几乎无延迟接受，consumer2每1.5秒接受一次，理论上consumer1接受的消息数是consumer2的三倍
下图是消费者2设置的延迟
在这里插入图片描述
(3)订阅模式-共享资源，应用场景：邮件群发、群聊、广播，生产者没有将消息直接发送到队列，而是发送到了交换机。
这里注意要绑定队列到交换机，需要在v_host1下新建exchange–exchange_name_subscribe（交换机名称，生产者将消息发送到这里）,并绑定queue–queue_test_subscribe/queue_test_subscribe2。
在这里插入图片描述
然后点击刚刚的交换机，进入绑定界面，绑定上queue_test_subscribe和queue_test_subscribe2
在这里插入图片描述

同理也是注释掉简单模式和work模式的代码，然后按顺序重新启动消费者1，消费者2和生产者。
结果如下：
在这里插入图片描述
在这里插入图片描述
可以看到两个消费者都消费到了同一条消息。

三、集成SpringBoot
1.添加相关的exchange和queue,exhcange包括DirectExchange、TopicExchange，queue包括DirectQueue、topic.qqMail，并绑定用DirectExchange绑定DirectQueue，TopicExchange绑定topic.qqMail、topic.qq。
在这里插入图片描述

2.添加相关配置
application.yml:

application:
    name: rabbitmq-provider
  #配置rabbitMq 服务器
rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: admin
    password: admin
    #虚拟host 可以不设置,使用server默认host
    virtual-host: v_host1

3.java代码，其中SendMsgController 充当生产者，XXXReceiver为消费者，XXXMqConfig为配置文件。

package com.example.springb_web.utils.SpringBootRabbitMq;

import org.apache.kafka.common.Uuid;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;

@RestController
public class SendMsgController {
    @Autowired
    RabbitTemplate rabbitTemplate;

    @GetMapping("/sendDirectMsg")
    public String sendDirectMsg(){
        String msgId = String.valueOf(Uuid.randomUuid());
        String msg = "Let'go Bradon!";
        String CreateTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map = new HashMap<>();
        map.put("msgId",msgId);
        map.put("msg",msg);
        map.put("CreateTime",CreateTime);
        rabbitTemplate.convertAndSend("DirectExchange","DirectRouting",map);
        return "sendDirectMsg";
    }

    @GetMapping("/sendQqTopicMsg")
    public String sendQqTopicMsg(){
        String msgId = String.valueOf(Uuid.randomUuid());
        String msg = "Let'go Bradon! -- qq";
        String CreateTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map = new HashMap<>();
        map.put("msgId",msgId);
        map.put("msg",msg);
        map.put("CreateTime",CreateTime);
        rabbitTemplate.convertAndSend("TopicExchange","topic.qq",map);
        return "sendQqTopicMsg";
    }

    @GetMapping("/sendQqMailTopicMsg")
    public String sendQqMailTopicMsg(){
        String msgId = String.valueOf(Uuid.randomUuid());
        String msg = "Let'go Bradon!  --qqMail";
        String CreateTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map = new HashMap<>();
        map.put("msgId",msgId);
        map.put("msg",msg);
        map.put("CreateTime",CreateTime);
        rabbitTemplate.convertAndSend("TopicExchange","topic.qqMail",map);
        return "sendQqMailTopicMsg";
    }

}


package com.example.springb_web.utils.SpringBootRabbitMq;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;



@Configuration
public class DirectExchangeMqConfig {

    @Bean
    public Queue GetDirectQueue(){
        //durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        return new Queue("DirectQueue",true);
    }

    @Bean
    public DirectExchange GetDirectExchange(){
        return new DirectExchange("DirectExchange",true,false);
    }

    //绑定  将队列和交换机绑定, 并设置用于匹配键：DirectRouting
    @Bean
    public Binding DirectBinding(){
        return BindingBuilder.bind(GetDirectQueue()).to(GetDirectExchange()).with("DirectRouting");
    }

}


package com.example.springb_web.utils.SpringBootRabbitMq;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
@RabbitListener(queues = "DirectQueue")//监听的队列名称 TestDirectQueue
public class DirectReceiver {
 
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("DirectReceiver消费者收到消息  : " + testMessage.toString());
    }
 
}

package com.example.springb_web.utils.SpringBootRabbitMq;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class TopicExchangeMqConfig {

    //绑定键
    public final static String qqMail = "topic.qqMail";
    public final static String qq = "topic.qq";


    @Bean
    public Queue GetQqMailQueue(){
        //durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
        // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
        // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
        return new Queue(qqMail,true);
    }

    @Bean
    public Queue GetQqQueue(){
        return new Queue(qq,true);
    }

    @Bean
    public TopicExchange GetTopicExchange(){
        return new TopicExchange("TopicExchange",true,false);
    }

    //绑定
    @Bean
    public Binding qqMailTopicBinding(){
        return BindingBuilder.bind(GetQqMailQueue()).to(GetTopicExchange()).with(qqMail);
    }
    //只要topic.qq开头的，不管topic.qq或者topic.qqMail，都会分发到该队列
    @Bean
    public Binding qqTopicBinding(){
        return BindingBuilder.bind(GetQqQueue()).to(GetTopicExchange()).with("topic.qq#");
    }

}

package com.example.springb_web.utils.SpringBootRabbitMq;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
@RabbitListener(queues = "topic.qqMail")
public class TopicQqMailReceiver {

    @RabbitHandler
    public void process(Map testMessage){
        System.out.println("TopicQqMailReceiver消费者收到消息  : " + testMessage.toString());
    }
}


package com.example.springb_web.utils.SpringBootRabbitMq;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
@RabbitListener(queues = "topic.qq")
public class TopicQqReceiver {

    @RabbitHandler
    public void process(Map testMessage){
        System.out.println("TopicQqReceiver消费者收到消息  : " + testMessage.toString());
    }
}

4.测试
启动SpringbWebApplication
(1)直连模式：
浏览器进入http://localhost:8080/sendDirectMsg，可以看到结果如下
在这里插入图片描述
(2)主题模式
浏览器进入http://localhost:8080/sendQqTopicMsg，可以看到结果如下（记得清空一下控制台）
在这里插入图片描述

浏览器进入http://localhost:8080/sendQqMailTopicMsg，可以看到结果如下
在这里插入图片描述
可以看到qqMail的消息qq也接收到了，但qq的消息qqMail没有接收到。
这是因为在TopicExchangeMqConfig中绑定时，一个是固定值，一个是通配符。
在这里插入图片描述

三、常见问题解决

1.前几次登录没问题，隔了一阵子后，突然启动不了。
推荐重新安装erlang和rabbitmq

TTTALK
关注
专栏目录
RabbitMQ教程(安装与使用详解,Spring集成)
鸟哥哥的专栏
12-26 50万+
RabbitMQ教程，面试题。消息队列(MQ)，本质是个队列，队列中存放的内容是message。MQ用于不同进程Process/线程Thread之间通信。本文介绍RabbitMQ的使用。RabbitMQ实战教程。
Rabbitmq笔记+入门教程+示例
02-23
RabbitMQ环境搭建，介绍队列类型，spring-rabbit示例， 使用RabbitMQ完成商品数据的同步
RabbitMq图形界面创建队列操作步骤及控制台使用说明
qq_34041723的博客
04-12 4693
版本：RabbitMQ 3.9.7 控台台访问路径： http://localhost:15672/#/queues（1）输入自定义的队列名称 （2）其他输入参数为默认值即可 （3）点击【Add queue】创建队列成功 登录后，您将看到 RabbitMQ 的控制台界面。该界面将显示以下几个主要部分：Overview：概览页面提供了关于 RabbitMQ 节点、队列和交换机等的统计信息。Connections：连接页面提供了有关当前客户端连接的详细信息。Channels：通道页面提供了有关当前打开通道的详细
RabbitMQ 使用教程
白白白鲤鱼的博客
08-11 2208
RabbitMQ使用教程
RabbitMQ的使用
X_Q_B_J的博客
03-10 1058
1、MQ是什么 MQ: Message Quene 消息队列 队列: 一种数据结构，先进先出 消息队列: 本质是个队列，只不过存放的是消息而已 消息中间件: 简单来说就是用来传输消息的中间载体 MQ的作用： 流量消峰(解决高并发) 模块之间的异步通信 MQ的框架很多，比如ActiveMQ，RabbitMQ，RocketMQ，kafka，而我们使用的就是RabbitMQ 2、Rabbit...
RabbitMQ的可视化界面进行操作--交换机和队列管理
MissOfSpring的博客
04-20 694
1.创建队列 2.创建交换机 3.交换机和队列绑定
RabbitMQ入门教程
最新发布
09-12
RabbitMQ入门教程
rabbitmq 入门教程
07-23
RabbitMQ 入门教程 RabbitMQ 是一个消息服务器，负责接收生产者生产的消息，并将其发送给消费者。在这个过程中，RabbitMQ 可以根据用户给定的规则来路由、缓存、持久化这些消息。下面是 RabbitMQ 中的一些专业术语...
RabbitMQ基础教程
04-19
### RabbitMQ基础教程知识点详解 #### 一、RabbitMQ简介 RabbitMQ是一种开源的消息代理和队列服务器，基于AMQP（Advanced Message Queuing Protocol）标准开发，它提供了多种编程语言的API接口，能够方便地与其他...
RabbitMQ 入门教程（JAVA）
08-01
### RabbitMQ 入门教程（JAVA） #### 一、RabbitMQ 概述 RabbitMQ 是一个消息中间件，其主要功能是接收来自生产者的消息，并根据规则将其路由、缓冲以及持久化后传递给消费者。RabbitMQ 和消息传递系统通常会使用...
RabbitMQ之动态创建队列与绑定交换机和监听器
weixin_62773839的博客
09-12 2688
为什么需要动态创建队列与绑定交换机？我在写项目的时候遇到这么个问题，我数据库中存在一个字段messageType指定为消息类型，消息类型存在三种，一种是通知类，一种是验证码类，一种是活动类。并且对应的，要将消息进行不同渠道的分发，还存在一个channelType，而他又存在QQ邮箱，手机短信、服务号三种不同的渠道。假如说我每增加一个渠道类型，我就必须再一次手动创建一个队列，那可太烦人了，并且还得新增一个新的监听器。
RabbitMq图形界面创建队列操作步骤
Thea_Li的博客
08-03 5144
RabbitMq
RabbitMQ 消息队列
bier_zm的博客
11-08 4297
什么是 RabbitMQ MQ（Message Queue）消息队列 消息队列中间件，是分布式系统中的重要组件； 主要解决异步处理、应用解耦、流量削峰等问题，从而实现高性能，高可用，可伸缩和最终一致性的架构。 使用较多的消息队列产品：RabbitMQ，RocketMQ，ActiveMQ，ZeroMQ，Kafka 等。 异步处理 用户注册后，需要发送验证邮箱和手机验证码。 将注册信息写入数据库，发送验证邮件，发送手机，三个步骤全部完成后，返回给客户端。 传统： 客户端 <-> 注
RabbitMQ管理界面说明
多学"亿"点的博客
11-11 2207
1、 RabbitMQ管理界面说明 connections：无论生产者还是消费者，都需要与RabbitMQ建立连接后才可以完成消息的生产和消费，在这里可以查看连接情况 channels：通道，建立连接后，会形成通道，消息的投递获取依赖通道。 Exchanges：交换机，用来实现消息的路由 Queues：队列，即消息队列，消息存放在队列中，等待消费，消费后被移除队列。 2、Admin用户和虚拟主机管理 上面的Tags选项，其实是指定用户的角色，可选的有以下几个： 超级管理员(adm
RabbitMQ消息队列创建
web18224617243的博客
04-22 884
操作环境 centos 7.9 RabbitMQ 3.8.23 Erlang 24.1.2 局域网（内网） 本文章是通过RabbitMQ图形管理界面，进行消息创建与队列绑定 首先在RabbitMQ安装时 图形操作(15672)端口是要打开，通过地址在浏览器进行访问，如是安装在云服务器上，可在安全组中将当前端口开放，也可以通过putty工具代理到本地进行访问。 接下来可以通过RabbitMQ自带的图形管理进行队列创建、把exchange和queue按照路由规则绑定起来 首先介绍一下图形中功能的意思 .
rabbitmq图形化界面使用
夜一
10-27 2666
一、简单模式simple 就是简单的生产者P生产信息，然后放到中间件rabbitmq，然后消费者C从中间件获得消息 1.创建队列queue2 2.创建的队列默认绑定默认的交换机，点击AMQP default 3.生产队列信息 4.交换机生产完信息，过5秒后生成一条队列信息 5.点击queue2进入，进行消费 二、工作模式work 就是交换机分别给队列1队列2发送消息，再分别给两个消费者消费，这样操作效果不明显，用代码看会明显一点 1.分别给routing key为queue1...
硬核，RabbitMQ入门使用教程，详细到哭
Javanewspaper的博客
12-31 9735
RabbitMQ 简介 RabbitMQ是使用Erlang语言开发的开源消息队列系统，基于AMQP协议来实现。AMQP的主要特征是面向消息、队列、路由(包括点对点和发布/订阅)、可靠性、 安全。AMQP协议更多用在企业系统内，对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。 MQ全称为Message Queue, 消息队列(MQ)是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息(针对应用程序的数据)来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在
RabbitMQ使用教程
热门推荐
Mr. Wu's blog
10-07 1万+
RabbitMQ使用教程，一文解决入门难题
乐优商城（二十四）——RabbitMQ及数据同步
lyj2018gyq的博客
10-19 3371
目录 一、RabbitMQ 1.1 搜索与商品服务的问题 1.2 消息队列（MQ） 1.2.1 什么是消息队列 1.2.2 AMQP和JMS 1.2.3 常见MQ产品 1.2.4 RabbitMQ 1.3 下载和安装 1.3.1 下载 1.3.2 安装 二、五种消息模型 2.1 基本消息模型 2.1.1 生产者发送消息 2.1.2 管理工具中查看消息 2.1.3 消费...
RabbitMQ入门教程解析
"这是一份关于RabbitMQ入门的教程文档，主要内容是对RabbitMQ的基本概念、工作原理以及使用Java客户端进行简单示例的介绍。" RabbitMQ是一种流行的消息中间件，它基于开放标准Advanced Message Queuing Protocol ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值