Topic模式模糊匹配

最新推荐文章于 2024-05-24 02:08:26 发布
最新推荐文章于 2024-05-24 02:08:26 发布
阅读量550 收藏 8
点赞数 8
分类专栏： rabbitmq 文章标签： java spring mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68935893/article/details/135449236
版权 
package com.java1234.producer.config;

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

@Configuration
public class RabbitMQConfig {


    /**
     * direct交换机名称
     */
    public static final String DIRECT_EXCHANGE="directExchange";

    /**
     * direct交换机名称1
     */
    public static final String DIRECT_EXCHANGE1="directExchange1";


    /**
     * fanout交换机名称
     */
    public static final String FANOUT_EXCHANGE="fanoutExchange";

    /**
     * direct队列名称
     */
    public static final String DIRECT_QUEUE="directQueue";

    /**
     * direct1队列名称
     */
    public static final String DIRECT_QUEUE1="directQueue1";

    /**
     * direct2队列名称
     */
    public static final String DIRECT_QUEUE2="directQueue2";

    /**
     * 订阅队列1名称
     */
    public static final String SUB_QUEUE1="subQueue1";
    /**
     * 订阅队列2名称
     */
    public static final String SUB_QUEUE2="subQueue2";

    /**
     * direct路由Key
     */
    public static final String DIRECT_ROUTINGKEY="directRoutingKey";

    /**
     * topic队列名称1
     *
     */
    public static final String TOPIC_QUEUE1="topicQueue1";

    /**
     * topic队列名称2
     *
     */
    public static final String TOPIC_QUEUE2="topicQueue2";


    /**
     * direct交换机名称
     */
    public static final String TOPIC_EXCHANGE="topicExchange";

    /**
     * 定义一个direct交换机
     * @return
     */
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange(DIRECT_EXCHANGE);
    }


    /**
     * 定义一个direct交换机1
     * @return
     */
    @Bean
    public DirectExchange directExchange1(){
        return new DirectExchange(DIRECT_EXCHANGE1);
    }


    /**
     * 定义一个direct交换机
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange(FANOUT_EXCHANGE);
    }

    /**
     * 定义一个direct队列
     * @return
     */
    @Bean
    public Queue directQueue(){
        return new Queue(DIRECT_QUEUE);
    }


    /**
     * 定义一个direct1队列
     * @return
     */
    @Bean
    public Queue directQueue1(){
        return new Queue(DIRECT_QUEUE1);
    }


    /**
     * 定义一个direct2队列
     * @return
     */
    @Bean
    public Queue directQueue2(){
        return new Queue(DIRECT_QUEUE2);
    }

    /**
     * 定义一个订阅队列1
     * @return
     */
    @Bean
    public Queue subQueue1(){
        return new Queue(SUB_QUEUE1);
    }

    /**
     * 定义一个订阅队列2
     * @return
     */
    @Bean
    public Queue subQueue2(){
        return new Queue(SUB_QUEUE2);
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
     public Binding directBinding(){
        return BindingBuilder.bind(directQueue()).to(directExchange()).with(DIRECT_ROUTINGKEY);
     }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding fanoutBinding1(){
        return BindingBuilder.bind(subQueue1()).to(fanoutExchange());
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding fanoutBinding2(){
        return BindingBuilder.bind(subQueue2()).to(fanoutExchange());
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding1(){
        return BindingBuilder.bind(directQueue1()).to(directExchange1()).with("error");
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding2(){
        return BindingBuilder.bind(directQueue2()).to(directExchange1()).with("info");
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding3(){
        return BindingBuilder.bind(directQueue2()).to(directExchange1()).with("error");
    }
    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding4(){
        return BindingBuilder.bind(directQueue2()).to(directExchange1()).with("warning");
    }

    /**
     * 定义一个topic队列1
     */
    @Bean
    public Queue topicQueue1(){
        return new Queue(TOPIC_QUEUE1);
    }

    /**
     * 定义一个topic队列2
     */
    @Bean
    public Queue topicQueue2(){
        return new Queue(TOPIC_QUEUE2);
    }


    /**
     * 定义一个direct交换机
     * @return
     */
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(TOPIC_EXCHANGE);
    }


    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding topicBinding1(){
        return BindingBuilder.bind(topicQueue1()).to(topicExchange()).with("*.orange.*");
    }



    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding topicBinding2(){
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("*.*.rabbit");
    }


    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding topicBinding3(){
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("lazy.#");
    }
}


package com.java1234.consumer.service.impl;

import com.java1234.consumer.service.RabbitMqService;
import com.java1234.producer.config.RabbitMQConfig;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("rabbitmqService")
public class RabbitMqServiceImpl implements RabbitMqService {

    @Autowired
    private AmqpTemplate amqpTemplate;

    @Override
    public void receiveMessage() {
        String message=(String) amqpTemplate.receiveAndConvert(RabbitMQConfig.DIRECT_QUEUE);
        System.out.println("接受到的mq消息："+message);
    }

    @Override
    @RabbitListener(queues = {RabbitMQConfig.TOPIC_QUEUE1})
    public void receiveMessage2(String message) {
//        System.out.println("消费者1：接收到的mq消息："+message);
                System.out.println("队列1接收日志消息："+message);
    }


    @Override
    @RabbitListener(queues = {RabbitMQConfig.TOPIC_QUEUE2})
    public void receiveMessage3(String message) {
//        System.out.println("消费者2：接收到的mq消息："+message);
                System.out.println("队列2接收日志消息："+message);

    }

    @Override
    @RabbitListener(queues = {RabbitMQConfig.SUB_QUEUE1})
    public void receiveSubMessage1(String message) {
        System.out.println("订阅者1：接收到的mq消息："+message);
    }

    @Override
    @RabbitListener(queues = {RabbitMQConfig.SUB_QUEUE2})
    public void receiveSubMessage2(String message) {
        System.out.println("订阅者2：接收到的mq消息："+message);
    }

}


package com.java1234.consumer.service;

public interface RabbitMqService {

    /**
     * 接受消息
     */
    public void receiveMessage();

    /**
     * 接受消息
     */
    public void receiveMessage2(String message);

    /**
     * 接受消息
     */
    public void receiveMessage3(String message);


    /**
     * 接受订阅消息1
     */
    public void receiveSubMessage1(String message);
    /**
     * 接受订阅消息2
     */
    public void receiveSubMessage2(String message);
}


package com.java1234.consumer;

import com.java1234.consumer.service.RabbitMqService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class ConsumerApplication {

    public static void main(String[] args) {
       ApplicationContext ac = SpringApplication.run(ConsumerApplication.class,args);
//        RabbitMqService rabbitMqService=(RabbitMqService) ac.getBean("rabbitmqService");
//        rabbitMqService.receiveMessage();
    }
}


package com.java1234.producer.service.impl;

import com.java1234.producer.config.RabbitMQConfig;
import com.java1234.producer.service.RabbitMqService;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("rabbitmqService")
public class RabbitMqServiceImpl implements RabbitMqService {

    @Autowired
    private AmqpTemplate amqpTemplate;

    /**
     * String exchange 交换机名称
     * String routingKey 路由Key
     * Object object 具体发送的消息
     * @param message
     */
    @Override
    public void sendMessage(String message) {
        amqpTemplate.convertAndSend(RabbitMQConfig.DIRECT_EXCHANGE,RabbitMQConfig.DIRECT_ROUTINGKEY,message);
    }

    @Override
    public void sendFanoutMessage(String message) {
        amqpTemplate.convertAndSend(RabbitMQConfig.FANOUT_EXCHANGE,"",message);
    }

    @Override
    public void sendRoutingMessage() {
        amqpTemplate.convertAndSend(RabbitMQConfig.DIRECT_EXCHANGE1,"warning2","发送warning2级别的消息");
    }

    @Override
    public void sendTopicMessage() {
//        amqpTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE,"quick.orange.rabbit","飞快的橘色兔子");
//                amqpTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE,"lazy.orange.elephant","慢腾腾的橘色大象");
//        amqpTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE,"quick.orange.fox","quick.orange.fox");
//        amqpTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE,"lazy.brown.fox","lazy.brown.fox");
        amqpTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE,"quick.brown.fox","quick.brown.fox");
    }
}


package com.java1234.producer.service;

public interface RabbitMqService {

    /**
     * 发送消息
     * @param message
     */
    public void sendMessage(String message);

    /**
     * 发送消息
     * @param message
     */
    public void sendFanoutMessage(String message);


    /**
     * 发送路由模式消息
     */
    public void sendRoutingMessage();

    /**
     * 发送Topic模式消息
     */
    public void sendTopicMessage();
}


package com.java1234.producer;

import com.java1234.producer.service.RabbitMqService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class ProducerApplication {

    public static void main(String[] args) {
        ApplicationContext ac = SpringApplication.run(ProducerApplication.class, args);
        RabbitMqService rabbitMqService=(RabbitMqService) ac.getBean("rabbitmqService");
//        rabbitMqService.sendRoutingMessage();
        rabbitMqService.sendTopicMessage();
        //        for(int i=0;i < 10;i++){
            rabbitMqService.sendMessage("RabbitMQ大爷你好！！！"+i);
//             rabbitMqService.sendFanoutMessage(i+"用户欠费了");
//        }
    }
}
九品印相
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
flume系列之：flume基于kafka.topics和kafka.topics.regex两种方式匹配Kafka Topic
zhengzaifeidelushang的博客
08-29 648
flume系列之：flume基于kafka.topics和kafka.topics.regex两种方式匹配Kafka Topic
RabbitMQ基本使用
weixin_48967543的博客
04-10 314
RabbitMQ免费优惠券 https://m.cps3.cn/ RabbitMQ可以说是目前较为火热的一款消息中间件，其本身由Erlang语言进行编写，部署简单操作方便，是必备的一门技术栈。 RabbitMQ官网 它支持各种主流语言的驱动，如下所示： 那么现在本章将用Python来探究一下RabbitMQ的使用。 RabbitMQ官方提供多种安装方式，具体可参照官网，这里将采用Docker部署，版本为3.8.14： docker run -d --name rabbitmq -p 5672:5672 .
一、kafka基本概念
m0_62866676的博客
11-13 1000
kafka入门到精通笔记
模糊匹配
mimsmile的博客
11-17 867
<if test="@org.apache.commons.lang.StringUtils@isNotBlank(queryContactedPatients.real_name)"> and real_name like '%'||#{queryContactedPatients.real_name}||'%' </if>
SpringBoot 集成Kafka操作详解
在每次的突破中遇见更好的自己
10-23 4361
目录[-] . 一、概念知识 . 什么是消息中间件 . 什么是 Kafka . Kafka 特性 . 使用场景 . 基本概念 . 生产者 ACKS 机制 . 消费者更新 Offset 偏移量两种方式 . 二、SpringBoot 操作 Kafka 示例 . 1、Maven 引入 Kafka 相关组件 . 2、Topic 配置 . 3、Producer 配置 . 4、Consumer 配置 . 三、SpringBoot 操作 Kafka 详解 . 1、Producer Templ
kafka 订阅模式
zhaoyangjian724的专栏
09-30 1044
>^Cnode1:/root/kafka_2.12-2.4.0#bin/kafka-console-producer.sh --broker-list 192.168.137.2:9092 --topic test_topic >aaaaaaaaa >bbbbbbbbb >ccccccccc >ddddddddd >eeeeeeeee >fffffffff >ggggggggg #!/usr/bin/env python # coding=utf-8..
Kafka学习一（概念理解，发布订阅模式入门）
无极
04-14 2970
定义 是一个分布式的基于发布/订阅模式的消息队列（Message Queue），主要应用于大数据实时处理领域 简单入门kafka 来源于B站：https://www.bilibili.com/video/BV1vx411f7hA 首先了解发布与订阅系统，想象一个公众号 运营公众号的人把文章发布到平台上，阅读者只要订阅相应的公众号，当有新的文章发布的时候阅读者就可以阅读到新的文章了。 这种发布者和阅...
浅谈发布订阅模式与观察者模式
12-01
设计模式并非是软件开发的专业术语，实际上，“模式”最早诞生于建筑学。 设计模式的定义是：在面向对象软件设计过程中针对特定问题的简洁而优雅的解决方案。通俗一点说，设计模式是在某种场合下对某个问题的一种...
ActiveMQ的队列、topic模式
11-22
ActiveMQ的两种消息模式的例子，queue和topic，注释很详细，告诉你每步做什么，非springboot整合
Spring Boot整合RabbitMQ实例（Topic模式）
08-30
Topic Exchange 转发消息主要是根据通配符。接下来通过本文给大家分享Spring Boot整合RabbitMQ实例（Topic模式），需要的朋友参考下吧
activemq的topic队列模式的maven，spring的demo
05-02
activemq的topic队列模式的maven，spring的demo
springboot2.1.4集成rabbitmq，三种模式：fanout direct topic的实现
05-16
springboot集成rabbitmq，三种模式：fanout direct topic的实现，入门级别
kafka 发布-订阅模式_使用Apache Kafka作为消息系统的发布-订阅通信中的微服务，并通过集成测试进行了验证...
最佳 Java 编程
07-08 1059
kafka 发布-订阅模式 发布-订阅消息系统在任何企业体系结构中都起着重要作用，因为它可以实现可靠的集成而无需紧密耦合应用程序。 在解耦的系统之间共享数据的能力并不是一个容易解决的问题。 考虑一个企业，其中具有使用不同语言和平台独立构建的多个应用程序。 它需要以响应方式共享数据和流程。 我们可以使用消息传递使用可定制的格式来频繁，立即，可靠且异步地传输数据包，从而实现这一目标。 从根本上...
kafka常用命令
xu19950210rou的博客
03-10 385
zookeeper连接串:10.114.11.233:2181,10.114.11.234:2181,10.114.11.235:2181/kafka kafka连接串:10.114.11.163:9092,10.114.11.141:9092,10.114.11.215:9092 topic名称:yx 在kafka的目录下 创建topic: ./bin/kafka-topics.sh --cr...
kafka
Ctrl_kun的博客
03-25 1023
文章目录消息队列的流派什么是 MQ目前留下的消息中间件有 Broker 的 MQ重 Topic轻 Topic无 Broker 的 MQ一、[Kafka](https://kafka.apache.org/)介绍1.Kafka的使用场景2.Kafka基本概念二、kafka基本使用1.安装前的环境准备2.启动kafka服务器3.创建主题topic4.发送消息5.消费消息几个注意点：三、Kafka中的关键细节1.消息的顺序存储2. 单播消息的实现3.多播消息的实现在一些业务场景中需要让一条消息被多个消费者消费，那
Topic匹配模式
记忆碎片
08-02 891
topic类型的交换器允许在RabbitMQ中使用模糊匹配来绑定自己感兴趣的信息: *（星号）表示一个单词 #（井号）表示零个或者多个单词 RoutingKey为“black.critical.high”的日志会投递到queue1和queue2,。 RoutingKey为“red.critical.high”的日志会只投递到queue2。
springboot kafka @KafkaListener 动态指定topics
热门推荐
星雨心梦的博客
05-16 1万+
@Configuration @Slf4j public class KafkaConfig implements InitializingBean { @Override public void afterPropertiesSet() throws Exception { String topicName = wireTopics(); Sys...
java学习和项目总结
最新发布
2301_79390585的博客
05-24 607
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
请画出Topic消息转发模式图
06-06
好的，以下是Topic消息转发模式的图示： ``` +-----------+ | | +---+ Topic +---+ | | Manager | | | +-----------+ | | | +---+----+ +---+----+ | | | | | PubSub | | PubSub | | Server | | Client | | | | | +--------+ +--------+ ``` 在这个模型中，Topic Manager 负责管理 Topic 的创建、删除和维护订阅者列表。PubSub Server 负责处理发布者发布消息和订阅者订阅消息的请求，它们通过网络连接进行通信。PubSub Client 是订阅者的客户端，它向 PubSub Server 订阅 Topic 并接收消息。当发布者发布消息到某个 Topic 时，PubSub Server 将其转发给所有订阅该 Topic 的订阅者，从而实现消息的发布和订阅。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值