飙血推荐
  • HTML教程
  • MySQL教程
  • JavaScript基础教程
  • php入门教程
  • JavaScript正则表达式运用
  • Excel函数教程
  • UEditor使用文档
  • AngularJS教程
  • ThinkPHP5.0教程

Springboot整合RabbitMQ

时间：2021-12-03  作者：匿名  

说明该篇文章内容包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用。

　　在安装完rabbitMq后，输入http://ip:15672/ ，是可以看到一个简单后台管理界面的。

在这个界面里面我们可以做些什么？
可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。

以上这些管理界面的操作在这篇暂时不做扩展描述，我想着重介绍后面实例里会使用到的。

首先先介绍一个简单的一个消息推送到接收的流程，提供一个简单的图：

黄色的圈圈就是我们的消息推送服务，将消息推送到 中间方框里面也就是 rabbitMq的服务器，然后经过服务器里面的交换机、队列等各种关系（后面会详细讲）将数据处理入列后，最终右边的蓝色圈圈消费者获取对应监听的消息。

常用的交换机有以下三种，因为消费者是从队列获取信息的，队列是绑定交换机的（一般），所以对应的消息推送/接收模式也会有以下几种：
Direct Exchange

直连型交换机，根据消息携带的路由键将消息投递给对应队列。

大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key 。
然后当一个消息携带着路由值为X，这个消息通过生产者发送给交换机时，交换机就会根据这个路由值X去寻找绑定值也是X的队列。

Fanout Exchange

扇型交换机，这个交换机没有路由键概念，就算你绑了路由键也是无视的。 这个交换机在接收到消息后，会直接转发到绑定到它上面的所有队列。

Topic Exchange

主题交换机，这个交换机其实跟直连交换机流程差不多，但是它的特点就是在它的路由键和绑定键之间是有规则的。
简单地介绍下规则：

* (星号) 用来表示一个单词 (必须出现的)
# (井号) 用来表示任意数量（零个或多个）单词
通配的绑定键是跟队列进行绑定的，举个小例子
队列Q1 绑定键为 *.TT.* 队列Q2绑定键为 TT.#
如果一条消息携带的路由键为 域名.B，那么队列Q1将会收到；
如果一条消息携带的路由键为域名，那么队列Q2将会收到；

主题交换机是非常强大的，为啥这么膨胀？
当一个队列的绑定键为 "#"（井号） 的时候，这个队列将会无视消息的路由键，接收所有的消息。
当 * (星号) 和 # (井号) 这两个特殊字符都未在绑定键中出现的时候，此时主题交换机就拥有的直连交换机的行为。
所以主题交换机也就实现了扇形交换机的功能，和直连交换机的功能。

另外还有 Header Exchange 头交换机 ，Default Exchange 默认交换机，Dead Letter Exchange 死信交换机，这几个该篇暂不做讲述。

本次实例教程需要创建2个springboot项目，一个生产者，一个消费者。

首先创建 生产者，

域名里用到的jar依赖：

        <!--rabbitmq-->
        <dependency>
            <groupId>域名</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

　　域名：

#本机端口
server:
  port: 8082
spring:
  #给项目来个名字
  application:
    name: rabbitmq-provider
  #配置rabbitMq 服务器
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest

　　然后先使用下direct exchange(直连型交换机),创建域名

package 域名.域名ig;

import 域名.core.*;
import 域名域名;
import 域名域名iguration;

import 域名Map;
import 域名;

/**
 * @Author : laz
 * @CreateTime : 2021/11/14
 * @Description :
 **/
@Configuration
public class DirectRabbitConfig {

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

        //一般设置一下队列的持久化就好,其余两个就是默认false
        return new Queue("TestDirectQueue",true);
    }

    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange TestDirectExchange() {
      //  return new DirectExchange("TestDirectExchange",true,true);
        return new DirectExchange("TestDirectExchange",true,false);
    }

    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingDirect() {

        return 域名(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
    }


}

　　然后写个简单的接口进行消息推送：

    @GetMapping("/sendDirectMessage")
    public String sendDirectMessage() {
        String messageId = 域名eOf(域名omUUID());
        String messageData = "test message, hello!";
        String createTime = 域名().format(域名ttern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map=new HashMap<>();
        域名("messageId",messageId);
        域名("messageData",messageData);
        域名("createTime",createTime);
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        域名ertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return "ok";
    }

　　将项目运行起来，调用这个接口：

 此时，在rabbitMq管理页面可以看到，有一条推送的消息。

 然后有一个消息等待被消费。

 此时，说明我们的生产者的消息已经生产成功，只需要等待消费者消费即可！

接下来创建消费者服务：

首先是域名文件的依赖：

        <!--rabbitmq-->
        <dependency>
            <groupId>域名</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

　　然后是域名:

server:
  port: 8083
spring:
  #给项目来个名字
  application:
    name: rabbitmq-consumer
  #配置rabbitMq 服务器
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest

然后是创建消息接收监听类，域名：

package 域名.域名ig;

import 域名.域名itHandler;
import 域名.域名itListener;
import 域名域名onent;

import 域名;

@Component
@RabbitListener(queues = "TestDirectQueue")//监听的队列名称 TestDirectQueue
public class DirectReceiver {

    @RabbitHandler
    public void process(Map testMessage) {
        域名tln("DirectReceiver消费者收到消息  : " + 域名ring());
    }

}

　　然后启动项目，可以看到生产者的消息，在这边被成功消费了。

 接下来是Topic Exchange交换机，配置文件以及依赖包不变，新建一个域名：

package 域名.域名ig;

import 域名.域名ing;
import 域名.域名ingBuilder;
import 域名.域名e;
import 域名.域名cExchange;
import 域名域名;
import 域名域名iguration;

/**
 * @Author : laz
 * @CreateTime : 2021/11/14
 * @Description :
 **/

@Configuration
public class TopicRabbitConfig {
    //绑定键
    public final static String man = "域名";
    public final static String woman = "域名n";

    @Bean
    public Queue firstQueue() {
        return new Queue(域名);
    }

    @Bean
    public Queue secondQueue() {
        return new Queue(域名n);
    }

    @Bean
    TopicExchange exchange() {
        return new TopicExchange("topicExchange");
    }


    //将firstQueue和topicExchange绑定,而且绑定的键值为域名
    //这样只要是消息携带的路由键是域名,才会分发到该队列
    @Bean
    Binding bindingExchangeMessage() {
        return 域名(firstQueue()).to(exchange()).with(man);
    }

    //将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.#
    // 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
    @Bean
    Binding bindingExchangeMessage2() {
        return 域名(secondQueue()).to(exchange()).with("topic.#");
    }

}

　　然后在创建两个接口，用于测试：

    @GetMapping("/sendTopicMessage1")
    public String sendTopicMessage1() {
        String messageId = 域名eOf(域名omUUID());
        String messageData = "message: M A N ";
        String createTime = 域名().format(域名ttern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> manMap = new HashMap<>();
        域名("messageId", messageId);
        域名("messageData", messageData);
        域名("createTime", createTime);
        域名ertAndSend("topicExchange", "域名", manMap);
        return "ok";
    }

    @GetMapping("/sendTopicMessage2")
    public String sendTopicMessage2() {
        String messageId = 域名eOf(域名omUUID());
        String messageData = "message: woman is all ";
        String createTime = 域名().format(域名ttern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> womanMap = new HashMap<>();
        域名("messageId", messageId);
        域名("messageData", messageData);
        域名("createTime", createTime);
        域名ertAndSend("topicExchange", "域名n123", womanMap);
        return "ok";
    }

　　然后在创建一个消费者域名：：

package 域名.域名ig;

import 域名.域名itHandler;
import 域名.域名itListener;
import 域名域名onent;
import 域名;

/**
 * @Author : laz
 * @CreateTime : 2021/11/14
 * @Description :
 **/
@Component
@RabbitListener(queues = "域名")
public class TopicManReceiver {

    @RabbitHandler
    public void process(Map testMessage) {
        域名tln("TopicManReceiver消费者收到消息  : " + 域名ring());
    }
}

　　然后再创建一个消费者域名：：

package 域名.域名ig;

import 域名.域名itHandler;
import 域名.域名itListener;
import 域名域名onent;
import 域名;

/**
 * @Author : laz
 * @CreateTime : 2021/11/14
 * @Description :
 **/

@Component
@RabbitListener(queues = "域名n")
public class TopicTotalReceiver {

    @RabbitHandler
    public void process(Map testMessage) {
        域名tln("TopicTotalReceiver消费者收到消息  : " + 域名ring());
    }
}

　　启动项目，调用sendTopicMessage1这个接口：

可以看到，两个消费者都消费了这条消息。

注意：

TopicManReceiver监听队列1，绑定键为：域名
TopicTotalReceiver监听队列2，绑定键为：topic.#
而当前推送的消息，携带的路由键为：域名

再调用sendTopicMessage2这个接口：

 这时，只有TopicTotalReceiver成功消费了。

然后是Fanout Exchang交换机：

首先，创建生产者：

package 域名.域名ig;

import 域名.域名ing;
import 域名.域名ingBuilder;
import 域名.域名utExchange;
import 域名.域名e;
import 域名域名;
import 域名域名iguration;
/**
 * @Author : laz
 * @CreateTime : 2021/11/14
 * @Description :
 **/

@Configuration
public class FanoutRabbitConfig {

    /**
     *  创建三个队列 ：fanout.A   fanout.B  fanout.C
     *  将三个队列都绑定在交换机 fanoutExchange 上
     *  因为是扇型交换机, 路由键无需配置,配置也不起作用
     */


    @Bean
    public Queue queueA() {
        return new Queue("fanout.A");
    }

    @Bean
    public Queue queueB() {
        return new Queue("fanout.B");
    }

    @Bean
    public Queue queueC() {
        return new Queue("fanout.C");
    }

    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    @Bean
    Binding bindingExchangeA() {
        return 域名(queueA()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeB() {
        return 域名(queueB()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeC() {
        return 域名(queueC()).to(fanoutExchange());
    }
}

　　同样写一个接口，用于生产一条消息：

    @GetMapping("/sendFanoutMessage")
    public String sendFanoutMessage() {
        String messageId = 域名eOf(域名omUUID());
        String messageData = "message: testFanoutMessage ";
        String createTime = 域名().format(域名ttern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        域名("messageId", messageId);
        域名("messageData", messageData);
        域名("createTime", createTime);
        域名ertAndSend("fanoutExchange", null, map);
        return "ok";
    }

　　接下来在消费者里面创建一个类，用于接收消息：

域名：

package 域名.域名ig;

import 域名.域名itHandler;
import 域名.域名itListener;
import 域名域名onent;
import 域名;
/**
 * @Author : laz
 * @CreateTime : 2021/11/14
 * @Description :
 **/
@Component
@RabbitListener(queues = "fanout.A")
public class FanoutReceiverA {

    @RabbitHandler
    public void process(Map testMessage) {
        域名tln("FanoutReceiverA消费者收到消息  : " +域名ring());
    }

}

　　

域名：

package 域名.域名ig;

import 域名.域名itHandler;
import 域名.域名itListener;
import 域名域名onent;
import 域名;
/**
 * @Author : laz
 * @CreateTime : 2021/11/14
 * @Description :
 **/
@Component
@RabbitListener(queues = "fanout.B")
public class FanoutReceiverB {

    @RabbitHandler
    public void process(Map testMessage) {
        域名tln("FanoutReceiverB消费者收到消息  : " +域名ring());
    }

}

　　

域名：

package 域名.域名ig;

import 域名.域名itHandler;
import 域名.域名itListener;
import 域名域名onent;
import 域名;

/**
 * @Author : laz
 * @CreateTime : 2021/11/14
 * @Description :
 **/
@Component
@RabbitListener(queues = "fanout.C")
public class FanoutReceiverC {

    @RabbitHandler
    public void process(Map testMessage) {
        域名tln("FanoutReceiverC消费者收到消息  : " +域名ring());
    }

}

　　最后启动项目，调用我们生产者的接口，查看消息消费情况：

 可以看到，这三个类都消费到消息。

好了，这篇Springboot整合rabbitMq教程就暂且到此。本文若有错误，还请各路大佬指正指正！

标签：编程
搜你所爱
大家在看
热搜标签
网站地图 | 注册 | 投稿
白菜窝
湘ICP备14001474号-3  投诉建议:234161800@qq.com   部分内容来源于网络，如有侵权，请联系删除。