rabbitmq几个常用的功能和注意的问题

最新推荐文章于 2024-04-25 23:01:38 发布
最新推荐文章于 2024-04-25 23:01:38 发布
阅读量282 收藏
点赞数
分类专栏： 消息 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l23456789o/article/details/106453152
版权

rabbitmq

简单模式

在这里插入图片描述

public class Send {
    private final static String QUEUE_NAME = "hello";
    public static void main(String[] argv) throws Exception {
        //创建链接 获取到channel
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String message = "Hello World!";
        //发送消息
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
        System.out.println(" [x] Sent '" + message + "'");
        //关闭资源
        channel.close();
        connection.close();
    }
}

public class Recv {

  private final static String QUEUE_NAME = "hello";

  public static void main(String[] argv) throws Exception {
   //创建链接 获取到channel
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();
	//声明队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
	//
	DeliverCallback deliverCallback = (consumerTag, delivery) -> {
    String message = new String(delivery.getBody(), "UTF-8");
    System.out.println(" [x] Received '" + message + "'");
};
//监听队列（参数为：队列名称，是否自动应答，“对数据 处理的方法”）
channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
  }
}

work 工作模式（轮询共同完成同一任务）

在这里插入图片描述

public class Send {
    private final static String QUEUE_NAME = "hello";
    public static void main(String[] argv) throws Exception {
        //创建链接 获取到channel
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //发送消息
		 String msg = "第" + i + "消息";
         channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        //关闭资源
        channel.close();
        connection.close();
    }
}

public class Recv {

  private final static String QUEUE_NAME = "hello";

  public static void main(String[] argv) throws Exception {
   //创建链接 获取到channel
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();
	//声明队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);
   
	//
 //定义一个消费者
        DefaultConsumer defaultConsumer = 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=>" + msg);
                //休眠2秒
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        boolean autoAck = true;
        channel.basicConsume(QUEUE_NAME, autoAck, defaultConsumer);
  }
}

work fair公平模式（能者多劳共同完成同一任务）

public class Sent {
    private static final String QUEUE_NAME = "test_work_fair_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取连接
        Connection connection = ConnectUtil.getConnection();
        //获取channel
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        /**
         * 每一个消费者发送确认消息之前，消息队列不发送下一个消息到消费者，依次值处理一个消息，
         * 限制发送给同一个消费者不得超过一条消息
         */
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);

        for (int i = 0; i < 50; i++) {
            String msg = "第" + i + "消息";
            //消息发送
            System.out.println(msg);
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
            Thread.sleep(i * 30);
        }
        channel.close();
        connection.close();
    }
}


public class Receive1 {
    private static final String QUEUE_NAME = "test_work_fair_queue";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        newApi();
    }
    private static void newApi() throws IOException, TimeoutException, InterruptedException {
        //获取连接
        Connection connection = ConnectUtil.getConnection();
        //获取channel
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //保证依次只分发一个
        channel.basicQos(1);
        //定义一个消费者
        DefaultConsumer defaultConsumer = 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=>" + msg);
                //休眠2秒
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck = false;// work fair   需要关闭自动应答模式

        channel.basicConsume(QUEUE_NAME, autoAck, defaultConsumer);
    }
}


public class Receive2 {
    private static final String QUEUE_NAME = "test_work_fair_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取连接
        Connection connection = ConnectUtil.getConnection();
        //获取channel
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.basicQos(1);//保证依次只接收一个消息
        DefaultConsumer defaultConsumer = 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("消费者2=>" + msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //手动回执消息
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck = false;// work fair 关闭自动应答
        channel.basicConsume(QUEUE_NAME, autoAck, defaultConsumer);
    }
}

订阅模式publish/subscribe 交换机类型fanout（根据路由key）

在这里插入图片描述

  • 发送
 channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        for (int i = 0; i < 50; i++) {
            //定义消息
            String msg = "fanout_message=>" + i;
            System.out.println(msg);
            //发送消息
            channel.basicPublish(EXCHANGE_NAME, "", null, msg.getBytes());
        }
  • 接收
public class Reveice1 {
    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 = ConnectUtil.getConnection();
        Channel channel = connection.createChannel();
        //队列声明
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //绑定队列到交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        //保证依次只分发一个
        channel.basicQos(1);
        //定义一个消费者
        DefaultConsumer defaultConsumer = 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("Reveice1=>" + msg);
                //休眠2秒
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        };
        boolean autoAck = false;// work fair   需要关闭自动应答模式
        channel.basicConsume(QUEUE_NAME, autoAck, defaultConsumer);
    }
}

public class Reveice2 {
    private static final String QUEUE_NAME = "test_queue_fanout_sms";
    private static final String EXCHANGE_NAME = "test_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectUtil.getConnection();
        Channel channel = connection.createChannel();
        //队列声明
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //绑定队列到交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        channel.basicQos(1);//保证一次只分发一个
        DefaultConsumer defaultConsumer=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("Reveice2=>"+msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck = false;//关闭自动应答
        channel.basicConsume(QUEUE_NAME, autoAck, defaultConsumer);
    }
}

订阅模式routing 交换机类型direct（）

在这里插入图片描述

public class Send {
    private static final String EXCHANGE_NAME = "test_exchange_direct";
    static List list = new LinkedList();
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        list.add("info");
        list.add("error");
        list.add("warning");
        for (Object s : list) {
            String msg = (String) s;
            System.out.println(msg);
            String routingKey = (String) s;
            channel.basicPublish(EXCHANGE_NAME, routingKey, null, msg.getBytes());
        }

        /*String msg = "hello direct";
        String routingKey = "error";
        channel.basicPublish(EXCHANGE_NAME,routingKey,null,msg.getBytes());
   */
    }
}

public class Revice1 {
    private static final String EXCHANGE_NAME = "test_exchange_direct";
    private static final String QUEUE_NAME = "test_queue_direct1";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectUtil.getConnection();
        Channel channel = connection.createChannel();
        //这个地方写错了 声明队列  中的参数写成了交换机
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.basicQos(1);
        //queueBind 写成了exechangeBind
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "error");

        DefaultConsumer defaultConsumer = 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(msg);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=false;
        channel.basicConsume(QUEUE_NAME, autoAck, defaultConsumer);
    }
}

topic模式（*#正则表达的方式）

在这里插入图片描述

public class Send {

    private final static String EXCHANGE_NAME = "test_exechange_topic";
    public static void main(String[] args) throws IOException, TimeoutException {

        Connection connection = ConnectUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");

        String msg = "test_exechange_topic";

        Map map = new HashMap();
        map.put("goods.add", "商品添加……");
        map.put("goods.delete", "商品删除……");
        map.put("goods.update", "商品修改……");
        map.put("goods.select", "商品查询……");
        map.put("goods.update.add", "商品add and update……");

        for (Object s:map.keySet()
             ) {
            String key = (String) s;
            String msg_ = (String) map.get(key);
            System.out.println(key + "<===>" + msg_);
            channel.basicPublish(EXCHANGE_NAME,key,false,null,msg_.getBytes());

        }
        channel.close();
        connection.close();
    }
}


public class Receive1 {
    private final static String EXCHANGE_NAME = "test_exechange_topic";
    private final static String QUEUE_NAME = "test_queue_topic1";
    public static void main(String[] args) throws IOException, TimeoutException {

        Connection connection = ConnectUtil.getConnection();
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "#.add");
        channel.basicQos(1);


        DefaultConsumer defaultConsumer=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("test_queue_topic1==>"+msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }

            }
        };

        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME, autoAck, defaultConsumer);


    }
}

public class Receive2 {
    private final static String EXCHANGE_NAME = "test_exechange_topic";
    private final static String QUEUE_NAME = "test_queue_topic2";
    public static void main(String[] args) throws IOException, TimeoutException {

        Connection connection = ConnectUtil.getConnection();
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "goods.*");
        channel.basicQos(1);


        DefaultConsumer defaultConsumer=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("test_queue_topic2==>"+msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }

            }
        };

        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME, autoAck, defaultConsumer);


    }
}
RabbitMQ
帅枫的博客
02-06 514
RabbitMQ 一、主流消息中间件介绍 一、ActiveMQ ActiveMQ是Apache出品，最流行的，能力强劲的开源消息总线，并且他是一个完全支持JMS规范的消息中间件。 七丰富的API，多种集群构建模式使得他称为业界老牌消息中间件，在中小型企业广泛应用！ MQ衡量指标：服务性能、数据存储、集群架构 二、Kafka Kafka是LinkedIn开源的分布式发布-订阅消息系统，目前归属于Apache顶级项目。Kafka主要特点是基于Pull的模式来处理消息消费，追求高吞吐量，一开始的目的就是用
RabbitMq
qq_45661125的博客
01-25 2209
Rabbitmq中间件什么是中间件为什么需要使用消息中间件中间件的特点消息中间件的本质及设计RabbitMQ使用场景解耦、削峰、异步高内聚，低耦合rabbitmq的几种工作模式 中间件 什么是中间件 中间件（Middleware）是处于操作系统和应用程序之间的软件，也有人认为它应该属于操作系统中的一部分。人们在使用中间件时，往往是一组中间件集成在一起，构成一个平台（包括开发平台和运行平台），但在这组中间件中必须要有一个通信中间件，即中间件+平台+通信，这个定义也限定了只有用于分布式系统中才能称为中间件，同时
RabbitMQ详细介绍
03-27
文档详细介绍了RabbitMQ的功能，以及各个功能用python语言的详细实现，对初学者有很大的帮助哦
RabbitMQ 功能概览
yueerba126的博客
10-30 468
📢 注意: 确保应用程序能够处理服务器过载或其他可能导致消息传递失败的情况。📢 注意: 是一个功能强大且灵活的消息中间件，但为了充分利用其功能并确保其稳定和高效运行，开发和运维团队都需要对其有深入的了解。RabbitMQ 是一个开源的消息队列系统，基于 AMQP（高级消息队列协议）设计。它被广泛应用于各种应用场景，如：异步任务处理、日志传输、实时消息推送等。 💻 Topic Exchange: 描述 主题交换机根据路由键的模式匹配将消息传递给绑定的队列。 Spring Cloud 使用 与直接交
Rabbitmq一些需要注意的点
不知跬步无至千里
07-12 838
生产者将消息发送到Exchange中，Exchange会根据绑定关系投递到队列，也就是如果生产者在生产消息时没有队列与之绑定消息就会丢失。为了保证系统更加健硕，一般无论是消息的生产者还是消费者都会新建一遍Exchange和Queue，新建后属性不会改变。同样AMQP_DURABLE代表这是一个持久化的队列，队列会被写入磁盘。需要注意的是虽然消息是缓存在队列中，但是并不是队列是持久化的队列队列中的消...
RabbitMQ使用注意事项
weixin_45584979的博客
08-30 244
场景：异步，削峰，解耦 在类上打此注解，这些也可以写在一个configration配置文件中，以bean的方式配置，绑定等等 @RabbitListener( bindings = @QueueBinding(value = @Queue(value = "q.column.share.data.change.column",durable = "true"), exchange = @Exchange(value = "amp.topic",type = ExchangeT
开发中使用RabbitMQ的注意事项
无德皇叔的博客
03-09 5943
使用消息队列处理消息的时候，我们可能会遇到以下问题： 消息处理失败消息体本身有误消息重复处理消息丢失 对于消息处理失败，有可能有由于网络波动导致的数据处理异常，待网络稳定时消息就会正常处理，对于这种处理失败，我们应该继续尝试去处理消息。消息体本身有误，这会导致消息连续处理失败，占用较多的资源，写大量的无用日志，这种错误应该丢弃这部分无用消息，但要记录下日志，记清消息体本身数据，以及丢弃消息
rabbitmq开发环境 -rabbitmq-server-3.8.1和otp_win64_22.1.rar
01-06
在安装和配置这两个组件时，需要注意以下几点： 1. 安装顺序：首先，你需要安装Erlang OTP，然后才是RabbitMQ。确保安装路径不含中文字符，以避免可能出现的问题。 2. 环境变量设置：安装完成后，需要将Erlang的bin...
PHP基于rabbitmq操作类的生产者和消费者功能示例
10-18
以下是该类中几个关键的方法： 1. setConfigs($configs)：设置RabbitMQ连接所需的配置信息，如主机地址、端口、用户名、密码和虚拟主机等。 2. setDurable($durable)：设置是否持久化，持久化可以在RabbitMQ重启后...
简单的RabbitMQ集成Springboot实现订单异步发送功能示例以及RabbitMQ的相关问题
captian_900331的博客
06-02 1622
【代码】简单的RabbitMQ集成Springboot实现订单异步发送功能示例。
RabbitMQ基本使用一(简单介绍)
pertty12350的博客
04-15 308
???????? 我是一名在互联网捡破烂的程序员，随着我们的体系越来越庞大，就电商项目来看，我们的系统也是越来越多，整个体系拆分成多个系统，系统之间的耦合度降低了很多。 ​ 那么今天我们来讲一讲RabbitMQ的基本应用。 官方网站 一、介绍： RabbitMQ是一个消息代理：它接收和转发消息。你可以把它当成一个邮局...
RabbitMQ最全使用教程-小白也能看懂
最新发布
2401_84557521的博客
04-25 5701
我还通过一些渠道整理了一些大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。还有专门针对JVM、SPringBoot、SpringCloud、数据库、Linux、缓存、消息中间件、源码等相关面试题。
RabbitMQ指南(1)-特性及功能
jerome_jun的专栏
11-01 1499
1、RabbitMQ功能描述 消息机制可以使软件应用之间可以相互连接调用。好似一个大型应用的组件一样，使用RabbitMQ，应用程序各组件（模块）、用户设备和用户数据可以相互通信。消息机制通过分离数据的发送和接收，从而达到异步处理和解耦。 通过消息机制，可以实现数据传输，非阻塞型操作，推送通知，发布/订阅，异步处理，work队列。 RabbitMQ是一个消息协调者——一个消息中间
什么是RabbitMQ？它的主要功能是什么？
jakelihua
09-14 1049
它可以在不同的应用程序、服务和系统之间传递消息，并确保消息的可靠性和顺序性。发布-订阅模式：RabbitMQ支持发布-订阅模式，其中一个生产者可以将消息发布到一个交换机（Exchange），然后多个消费者可以订阅这个交换机，并接收到相应的消息。路由和过滤：RabbitMQ提供了灵活的路由和过滤机制，可以根据消息的路由键（Routing Key）将消息路由到不同的队列，以及根据消息的属性进行过滤。消息确认机制：RabbitMQ支持消息的确认机制，生产者可以在发送消息后等待消费者的确认，确保消息被成功处理。
RabbitMQ（四）rabbitMQ的常见问题
qq_40634246的博客
03-01 496
1、rabbitmq 的使用场景有哪些？ ①. 跨系统的异步通信，所有需要异步交互的地方都可以使用消息队列。就像我们除了打电话（同步）以外，还需要发短信，发电子邮件（异步）的通讯方式。 ②. 多个应用之间的耦合，由于消息是平台无关和语言无关的，而且语义上也不再是函数调用，因此更适合作为多个应用之间的松耦合的接口。基于消息队列的耦合，不需要发送方和接收方同时在线。在企业应用集成（EAI）中，文件传输...
RabbitMQ：Queue的介绍和使用
编程学习者的博客
05-13 7119
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）入门到进阶
lxy1740的博客
02-14 768
消息中间件​ 简介： 消息队列中间件(Message Queue Middleware ，简称为MQ) 是指利用高效可靠的消息传递 机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传 递和消息排队模型，它可以在分布式环境下扩展进程间的通信。 目前开源的消息中间件有很多，比较主流的有RabbitMQ 、Kafka、ActiveMQ 、RocketMQ 等。 书签： R...
RabbitMQ常见问题
shanchahua123456的博客
11-21 6333
参考：https://blog.csdn.net/youbl/article/details/80425959 0、防止消息丢失 生产者：confire模式。异步等待MQ回调通知是否接收到消息，判断是否重发。 MQ：持久化。设置Queue持久化 + Msg持久化deliveryMode=2 消费者：手动ACK。注意：超时、死循环、Qos、幂等 1、自动ack机制会导致消息丢失的问题 ...
RabbitMQ消息中间件快速入门
欢迎来到编程小栈
07-19 2491
文章目录一、同步和异步通讯1. 同步通讯2. 异步通讯二、RabbitMQ1. MessageQueue对比2. RabbitMQ快速入门【1】安装与启动【2】基本结构3. 五种消息模型介绍【1】入门案例1）publisher实现2）consumer实现4. SpringAMQP实现【1】Basic Queue 基本消息队列1）消息发送2）消息接收3）测试【2】WorkQueue工作消息队列1）消息发送2）消息接收3）测试4）prefetch提前获取【3】发布订阅三种模式1）Fanout[1] 声明队列和交
使用Dubbo、Solr和RabbitMQ实现高效数据同步方案
这通常涉及以下几个步骤： 1. Dubbo服务的定义和实现，包括数据同步服务的接口和实现类。 2. RabbitMQ消息队列的创建，以及生产者和消费者的配置。 3. Solr服务端的配置，包括核心的创建、schema的定义和字段映射。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值