SpringBoot 整合 AMQP（RabbitMQ）-低调大师

SpringBoot 整合 AMQP（RabbitMQ）

2019-08-12 635

SpringBoot整合AMQP（RabbitMQ）

添加pom依赖

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

application.properties配置

spring.rabbitmq.host=***.***.***.***
spring.rabbitmq.port=5762
spring.rabbitmq.username=admin
spring.rabbitmq.password=***

在RabbitMQ中所有的消息生产者提交的消息都会交由Exchange进行再分配，Exchange会根据不同的策略将消息分发到不同的Queue中。RabbitMQ提供了4种不同策略，分别是Direct、Fanout、Topic、Header，4种策略中前三种使用率较高

Direct

DirectExchange的路由策略是将消息队列绑定到一个DirectExchange上，但一条消息到达DirectExchange时会被转发到与该条消息routing key相同的Queue上

DirectExchange的配置如下：

/**
 * @author wsyjlly
 * @create 2019.07.17 - 21:33
 **/
@Configuration
public class RabbitDirectConfig {
    public final static String DIRECTNAME = "ysw-direct";
    @Bean
    Queue queue1(){
        return new Queue("queue-direct1");
    }

    @Bean

    Queue queue2(){
        return new Queue("queue-direct2");
    }

    @Bean
    Queue queue3(){
        return new Queue("queue-direct3");
    }

    @Bean
    DirectExchange directExchange(){
        return new DirectExchange(DIRECTNAME,true,false);
    }

    @Bean
    Binding binding1(){
        return BindingBuilder.bind(queue1()).to(directExchange()).with("direct1");
    }

    @Bean
    Binding binding2(){
        return BindingBuilder.bind(queue2()).to(directExchange()).with("direct2");
    }
}

DirectExchange和Binding两个Bean的配置可以省略掉，即如果使用DirectExchange，之配置一个Queue的实例即可

配置消费者

/**
 * @author wsyjlly
 * @create 2019.07.17 - 21:42
 **/
@Component
public class DirectReceiver {
    Logger logger= LoggerFactory.getLogger(getClass());

    @RabbitListener(queues = "queue-direct1")
    public void directHandler1(String msg){
        logger.info("\033[30;4m"+"queue-direct1:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-direct2")
    public void directHandler2(String msg){
        logger.info("\033[30;4m"+"queue-direct2:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-direct3")
    public void directHandler3(String msg){
        logger.info("\033[30;4m"+"queue-direct3:"+msg+"\033[0m");
    }
}

通过@RabbitListener注解指定一个方法是一个消费者方法，方法参数就是所接收的消息。

消息发送

通过注入RabbitTemplate对象来进行消息发送，在这里我通过定时任务使其自定发送，须开启定时任务，详细操作可查看一节

/**
 * @author wsyjlly
 * @create 2019.07.18 - 1:13
 **/
@Component
public class RabbitmqSchedule {
    @Autowired
    RabbitTemplate rabbitTemplate;
    Logger logger = LoggerFactory.getLogger(getClass());

    @Scheduled(fixedDelay = 5000,initialDelay = 3000)
    public void direct(){
        String message = "direct-task";
        logger.info("\033[30;4m"+message+"\033[0m");
        rabbitTemplate.convertAndSend("ysw-direct","direct1",message);
        rabbitTemplate.convertAndSend("ysw-direct","direct2",message);
        rabbitTemplate.convertAndSend("queue-direct3",message);
    }
}

Fanout

FanoutExchange的数据交换策略是把所有到达FanoutExchange的消息转发给所有与他绑定的Queue，在这种策略中，routingkey将不起作用。

FanoutExchange的配置方式如下：

/**
 * @author wsyjlly
 * @create 2019.07.17 - 21:33
 **/
@Configuration
public class RabbitFanoutConfig {
    public final static String FANOUTNAME = "ysw-fanout";

    @Bean
    Queue queue4(){
        return new Queue("queue-fanout1");
    }

    @Bean
    Queue queue5(){
        return new Queue("queue-fanout2");
    }

    @Bean
    Queue queue6(){
        return new Queue("queue-fanout3");
    }

    @Bean
    FanoutExchange fanoutExchange(){
        return new FanoutExchange(FANOUTNAME,true,false);
    }

    @Bean
    Binding binding4(){
        return BindingBuilder.bind(queue4()).to(fanoutExchange());
    }

    @Bean
    Binding binding5(){
        return BindingBuilder.bind(queue5()).to(fanoutExchange());
    }

    @Bean
    Binding binding6(){
        return BindingBuilder.bind(queue6()).to(fanoutExchange());
    }
}

配置消费者

/**
 * @author wsyjlly
 * @create 2019.07.17 - 21:42
 **/
@Component
public class FanoutReceiver {
    Logger logger= LoggerFactory.getLogger(getClass());

    @RabbitListener(queues = "queue-fanout1")
    public void fanoutHandler1(String msg){
        logger.info("\033[31;4m"+"queue-fanout1:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-fanout2")
    public void fanoutHandler2(String msg){
        logger.info("\033[31;4m"+"queue-fanout2:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-fanout3")
    public void fanoutHandler3(String msg){
        logger.info("\033[31;4m"+"queue-fanout3:"+msg+"\033[0m");
    }
}

消息发送

/**
 * @author wsyjlly
 * @create 2019.07.18 - 1:13
 **/
@Component
public class RabbitmqSchedule {
    @Autowired
    RabbitTemplate rabbitTemplate;
    Logger logger = LoggerFactory.getLogger(getClass());

    Scheduled(fixedDelay = 5000,initialDelay = 4000)
    public void fanout(){
        String message = "fanout-task";
        logger.info("\033[31;4m"+message+"\033[0m");
        rabbitTemplate.convertAndSend("ysw-fanout",null,message);
    }
}

Topic

TopicExchange是比较复杂也比较灵活的一种路由策略，在TopicExchange中，Queue通过routingkey绑定到TopicExchange上，当消息发送到TopicExchange后，TopicExchange根据消息的routingkey将消息路由到一个或多个Queue上。

TopicExchange配置如下：

/**
 * @author wsyjlly
 * @create 2019.07.17 - 21:33
 **/
@Configuration
public class RabbitTopicConfig {
    public final static String TOPIC_NAME = "ysw-topic";
    @Bean
    Queue queue7(){
        return new Queue("queue-topic1");
    }

    @Bean
    Queue queue8(){
        return new Queue("queue-topic2");
    }

    @Bean
    Queue queue9(){
        return new Queue("queue-topic3");
    }

    @Bean
    TopicExchange topicExchange(){
        return new TopicExchange(TOPIC_NAME,true,false);
    }

    @Bean
    Binding binding7(){
         /*
         * 匹配规则
         * 绑定键binding key也必须是这种形式。以特定路由键发送的消息将会发送到所有绑定键与之匹配的队列中。但绑定键有两种特殊的情况：
         * 绑定键binding key也必须是这种形式。以特定路由键发送的消息将会发送到所有绑定键与之匹配的队列中。但绑定键有两种特殊的情况：
         * ①*（星号）仅代表一个单词
         * ②#（井号）代表任意个单词
         **/
        return BindingBuilder.bind(queue7()).to(topicExchange()).with("#.topic1");
    }

    @Bean
    Binding binding8(){
        return BindingBuilder.bind(queue8()).to(topicExchange()).with("topic2.#");
    }

    @Bean
    Binding binding9(){
        return BindingBuilder.bind(queue9()).to(topicExchange()).with("#.topic3.*");
    }
}

配置消费者

/**
 * @author wsyjlly
 * @create 2019.07.17 - 21:42
 **/
@Component
public class TopicReceiver {
    Logger logger= LoggerFactory.getLogger(getClass());

    @RabbitListener(queues = "queue-topic1")
    public void topicHandler1(String msg){
        logger.info("\033[32;4m"+"queue-topic1:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-topic2")
    public void topicHandler2(String msg){
        logger.info("\033[32;4m"+"queue-topic2:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-topic3")
    public void topicHandler3(String msg){
        logger.info("\033[32;4m"+"queue-topic3:"+msg+"\033[0m");
    }
}

消息发送

/**
 * @author wsyjlly
 * @create 2019.07.18 - 1:13
 **/
@Component
public class RabbitmqSchedule {
    @Autowired
    RabbitTemplate rabbitTemplate;
    Logger logger = LoggerFactory.getLogger(getClass());

    @Scheduled(cron = "0-30/6 * * * * ?")
    public void topic(){
        String message = "topic-task";
        int i = 0;
        logger.info("\033[32;4m"+message+"\033[0m");
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic1.news",message + 1);//topic1
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic1.salary",message + 2);//topic1
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic2.news",message + 3);//topic2
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic2.item",message + 4);//topic2
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic2.sth.topic1",message + 5);//topic2&topic1
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic1.sth.topic2",message + 6);//topic2&topic1
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic3",message + 7);//topic3
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic3.news",message + 8);//topic3
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic1.topic3",message + 9); //topic1&topic3
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic2.topic3",message + 10);//topic2&topic3
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic3.topic1",message + 11);//topic3&topic1
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic2.topic3.topic1",message + 12);//topic1&topic2&topic3
    }
}

Header

HeaderExchange是一种较少使用的路由策略，HeaderExchange会根据消息的Header将消息路由到不同的Queue上，这种策略也和routingkey无关。

HeaderExchange配置如下：

/**
 * @author wsyjlly
 * @create 2019.07.17 - 21:33
 **/
@Configuration
public class RabbitHeaderConfig {
    public final static String HEADER_NAME = "ysw-header";
    @Bean
    Queue queue10(){
        return new Queue("queue-header1");
    }

    @Bean

    Queue queue11(){
        return new Queue("queue-header2");
    }

    @Bean
    Queue queue12(){
        return new Queue("queue-header3");
    }

    @Bean
    HeadersExchange headersExchange(){
        return new HeadersExchange(HEADER_NAME,true,false);
    }

    @Bean
    Binding binding10(){
        Map<String,Object> map = new HashMap<>();
        map.put("age", "18");
        map.put("name", "ysw");
        return BindingBuilder.bind(queue10()).to(headersExchange()).whereAny(map).match();
    }

    @Bean
    Binding binding11(){
        Map<String,Object> map = new HashMap<>();
        map.put("name", "ysw");
        return BindingBuilder.bind(queue11()).to(headersExchange()).where("age").exists();
    }

    @Bean
    Binding binding12(){
        Map<String,Object> map = new HashMap<>();
        map.put("age", "18");
        map.put("name", "ysw");
        return BindingBuilder.bind(queue12()).to(headersExchange()).whereAll(map).match();
    }
}

Binding配置注释：whereAny表示消息的Header中只要有一个Header匹配上map中的key/value，就把该消息路由到名为“queue-header1”的Queue上；whereAll方法表示消息的所有Header都要匹配，才将消息路由到名为“queue-header2”的Queue上；where表示只要消息的header中包含age，无论age值为多少，都将消息路由到名为“queue-header2”的Queue上。

配置消费者

/**
 * @author wsyjlly
 * @create 2019.07.17 - 21:42
 **/
@Component
public class HeaderReceiver {
    Logger logger= LoggerFactory.getLogger(getClass());

    @RabbitListener(queues = "queue-header1")
    public void headerHandler1(byte[] msg){
        logger.info("\033[33;4m"+"queue-header1:"+new String(msg,0,msg.length)+"\033[0m");
    }

    @RabbitListener(queues = "queue-header2")
    public void headerHandler2(byte[] msg){
        logger.info("\033[33;4m"+"queue-header2:"+new String(msg,0,msg.length)+"\033[0m");
    }

    @RabbitListener(queues = "queue-header3")
    public void headerHandler3(byte[] msg){
        logger.info("\033[33;4m"+"queue-header3:"+new String(msg,0,msg.length)+"\033[0m");
    }
}

消息发送

/**
 * @author wsyjlly
 * @create 2019.07.18 - 1:13
 **/
@Component
public class RabbitmqSchedule {
    @Autowired
    RabbitTemplate rabbitTemplate;
    Logger logger = LoggerFactory.getLogger(getClass());

    @Scheduled(cron = "0-30/3 * * * * ?")
    public void header(){
        String message = "header-task";
        logger.info("\033[33;4m"+message+"\033[0m");

        Message message1 = MessageBuilder.withBody("name=name".getBytes())
        .setHeader("name", "aaa").build();
        Message message2 = MessageBuilder.withBody("name=ysw".getBytes())
        .setHeader("name", "ysw").build();
        Message message3 = MessageBuilder.withBody("age=19".getBytes())
        .setHeader("age", "19").build();
        Message message4 = MessageBuilder.withBody("age=18".getBytes())
        .setHeader("age", "18").build();
        Message message5 = MessageBuilder.withBody("name=ysw&age=18".getBytes())
        .setHeader("name", "ysw").setHeader("age","18").build();
        Message message6 = MessageBuilder.withBody("name=ysw&age=19".getBytes())
        .setHeader("name", "ysw").setHeader("age","19").build();
        Message message7 = MessageBuilder.withBody("name=aaa&age=18".getBytes())
        .setHeader("name", "aaa").setHeader("age","18").build();

        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message1);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message2);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message3);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message4);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message5);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message6);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message7);
    }
}

微信关注我们

原文链接：https://yq.aliyun.com/articles/713974

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

SpringBoot 整合 JMS（ActiveMQ）

SpringBoot整合JMS（ActiveMQ）消息队列（Message Queue）是一种进程间或线程间的异步通信方式，使用消息队列消息生产者在消息产生后，会将消息保存在消息队列中直到消费者来取走它，即消息的发送者和接收者不需要与消息队列交互。使用消息队列可以可以有效实现服务的解耦，并提高系统的可靠性一级可扩展性。 JMS（Java Message Service）即Java消息服务，通过同一Java API层面的标准，使得多个客户端可以通过JMS进行交互，大多数消息中间件都对JMS提供支持。JMS包括两种消息模型：点对点发布者/订阅者 JMS仅支持Java平台添加pom依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-activemq</artifactId> </dependency> application.properties配置 spring.activemq....

2019-08-13

696

SpringBoot自定义Banner 官方提供的application.yml的banner配置信息 # BANNER spring.banner.charset=UTF-8 # Banner file encoding. spring.banner.location=classpath:banner.txt # Banner text resource location. spring.banner.image.location=classpath:banner.gif # Banner image file location (jpg or png can also be used). spring.banner.image.width=76 # Width of the banner image in chars. spring.banner.image.height= # Height of the banner image in chars (default based on image height). spring.banner.image.margin=2 # Lef...

2019-08-13

724

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。