二、原生Java客户端与RabbitMQ通信

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量189 收藏 1
点赞数
分类专栏： # RabbitMQ 文章标签： 队列 rabbitmq java 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcdlove/article/details/109455505
版权

原生Java客户端与RabbitMQ通信

1.Direct

Maven依赖：

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

DirectProducer：direct类型交换器的生产者

package exchange.direct;

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

/**
 */
public class DirectProducer {

    public final static String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {
        //创建连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("127.0.0.1");
        Connection connection = connectionFactory.newConnection();

        //创建信道
        Channel channel = connection.createChannel();

        //创建交换器
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

        //日志消息级别，作为路由键使用
        String[] serverities = {"error", "info", "warning"};

        for (int i = 0; i < 9; i++) {
            String severity = serverities[i % 3];
            String msg = "Hellol,RabbitMq" + (i + 1);

            //发布消息
            channel.basicPublish(EXCHANGE_NAME, severity, null, msg.getBytes());
        }
        channel.close();
        connection.close();
    }

}

NormalConsumer：普通的消费者

package exchange.direct;

import com.rabbitmq.client.*;

import java.io.IOException;

/**
 */
public class NormalConsumer {

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");

        //打开连接和创建信道，与发送端一样
        Connection connection = factory.newConnection();

        Channel channel = connection.createChannel();

        channel.exchangeDeclare(DirectProducer.EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

        //声明一个队列
        String queueName = "focuserror";

        channel.queueDeclare(queueName, false, false,
                false, null);

        //将队列和交换器通过路由键绑定,表示只关注info级别的消息
        String routeKey = "info";
        channel.queueBind(queueName, DirectProducer.EXCHANGE_NAME, routeKey);

        System.out.println("waiting for message........");

        //声明一个消费者
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println("Received[" + envelope.getRoutingKey()
                        + "]" + message);
            }
        };

        channel.basicConsume(queueName, true, consumer);
    }
}

MulitBindConsumer：队列绑定到交换器上时，是允许绑定多个路由键的，也就是多重绑定

package exchange.direct;

import com.rabbitmq.client.*;

import java.io.IOException;

/**
 */
public class QueueMulitBindExchange {

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");

        Connection connection = factory.newConnection();

        Channel channel = connection.createChannel();

        channel.exchangeDeclare(DirectProducer.EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

        String queueName = channel.queueDeclare().getQueue();

        //队列绑定多个路由键
        String[] severities = {"error", "info", "warning"};

        for (String serverity : severities) {
            channel.queueBind(queueName, DirectProducer.EXCHANGE_NAME, serverity);
        }

        System.out.println(" [*] Waiting for messages:");

        // 创建队列消费者
        final Consumer consumerA = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties
                                               properties,
                                       byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" Received "
                        + envelope.getRoutingKey() + ":'" + message
                        + "'");
            }
        };
        channel.basicConsume(queueName, true, consumerA);
    }
}

MulitChannelConsumer：一个连接下允许有多个信道

package exchange.direct;

import com.rabbitmq.client.*;

import java.io.IOException;

/**
 */
public class MulitChannelConsumer {

    public static void main(String[] args) throws Exception {

        ConnectionFactory factory = new ConnectionFactory();

        factory.setHost("127.0.0.1");

        Connection connection = factory.newConnection();

        //一个连接多个信道
        for(int i = 0; i < 3; i++){
            Thread worker = new Thread(new ConsumerWorker(connection));
            worker.start();
        }

    }

    private static class ConsumerWorker implements Runnable {

        final Connection connection;

        public ConsumerWorker(Connection connection) {
            this.connection = connection;
        }

        @Override
        public void run() {
            try {
                Channel channel = connection.createChannel();

                channel.exchangeDeclare(DirectProducer.EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

                String queueName = channel.queueDeclare().getQueue();

                //消费者名字，打印输出用
                final String consumerName
                        = Thread.currentThread().getName() + "-all";

                //所有日志严重性级别
                String[] severities={"error","info","warning"};
                for (String severity : severities) {
                    //关注所有级别的日志（多重绑定）
                    channel.queueBind(queueName,
                            DirectProducer.EXCHANGE_NAME, severity);
                }
                System.out.println("["+consumerName+"] Waiting for messages:");

                // 创建队列消费者
                final Consumer consumerA = new DefaultConsumer(channel) {
                    @Override
                    public void handleDelivery(String consumerTag,
                                               Envelope envelope,
                                               AMQP.BasicProperties
                                                       properties,
                                               byte[] body)
                            throws IOException {
                        String message =
                                new String(body, "UTF-8");
                        System.out.println(consumerName
                                +" Received "  + envelope.getRoutingKey()
                                + ":'" + message + "'");
                    }
                };
                channel.basicConsume(queueName, true, consumerA);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

MulitConsumerOneQueue：一个队列多个消费者，则会表现出消息在消费者之间的轮询发送。

package exchange.direct;

import com.rabbitmq.client.*;

import java.io.IOException;

/**
 */
public class MulitConsumerOneQueue {

    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");

        Connection connection = factory.newConnection();

        String queueName = "focusAll";

        for (int i = 0; i < 3; i++) {
            //一个连接多个信道，多个信道共享同一个队列
            Thread worker = new Thread(new ConsumerWorker(connection, queueName));

            worker.start();
        }
    }

    private static class ConsumerWorker implements Runnable {

        final Connection connection;

        final String queueName;

        public ConsumerWorker(Connection connection, String queueName) {
            this.connection = connection;
            this.queueName = queueName;
        }

        @Override
        public void run() {
            try {
                Channel channel = connection.createChannel();

                channel.exchangeDeclare(DirectProducer.EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

                channel.queueDeclare(queueName, false, false, false, null);

                final String consumerName
                        = Thread.currentThread().getName();

                //所有日志严重性级别
                String[] severities={"error","info","warning"};

                for (String severity : severities) {
                    //关注所有级别的日志（多重绑定）
                    channel.queueBind(queueName, DirectProducer.EXCHANGE_NAME, severity);
                }
                System.out.println(" ["+consumerName+"] Waiting for messages:");

                // 创建队列消费者
                final Consumer consumerA = new DefaultConsumer(channel) {
                    @Override
                    public void handleDelivery(String consumerTag,
                                               Envelope envelope,
                                               AMQP.BasicProperties
                                                       properties,
                                               byte[] body)
                            throws IOException {
                        String message =
                                new String(body, "UTF-8");
                        System.out.println(consumerName
                                +" Received "  + envelope.getRoutingKey()
                                + ":'" + message + "'");
                    }
                };
                channel.basicConsume(queueName, true, consumerA);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

2.Fanout

消息广播到绑定的队列

  • 生产者
package exchange.fanout;

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

/**
 */
public class FanoutProducer {

    public final static String EXCHANGE_NAME = "fanout_logs";

    public static void main(String[] args) throws Exception {

        ConnectionFactory factory = new ConnectionFactory();

        factory.setHost("127.0.0.1");

        Connection connection = factory.newConnection();

        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);

        //所有日志严重性级别
        String[] severities = {"error", "info", "warning"};

        for (int i = 0; i < 3; i++) {
            String severity = severities[i % 3];

            // 发送的消息
            String message = "Hello World_"+(i+1);

            channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes());

            System.out.println(" [x] Sent '" + severity +"':'"
                    + message + "'");
        }
        // 关闭频道和连接
        channel.close();
        connection.close();
    }

}
  • 消费者1
package exchange.fanout;

import com.rabbitmq.client.*;

import javax.swing.event.ChangeListener;
import java.io.IOException;

/**
 */
public class Consumer1 {

    public static void main(String[] args) throws Exception{
        ConnectionFactory factory = new ConnectionFactory();

        factory.setHost("127.0.0.1");

        Connection connection = factory.newConnection();

        Channel channel = connection.createChannel();

        channel.exchangeDeclare(FanoutProducer.EXCHANGE_NAME, BuiltinExchangeType.FANOUT);

        //声明一个随机队列
        String queueName = channel.queueDeclare().getQueue();

        //所有日志严重性级别
        String[] severities={"error","info","warning"};
        for (String severity : severities) {
            //关注所有级别的日志（多重绑定）
            channel.queueBind(queueName, FanoutProducer.EXCHANGE_NAME, severity);
        }
        System.out.println(" [*] Waiting for messages:");

        // 创建队列消费者
        final Consumer consumerA = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" Received "  + envelope.getRoutingKey() + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumerA);
    }
}
  • 消费者2
package exchange.fanout;

import com.rabbitmq.client.*;

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

/**
 * @Author: Rab
 * @Date: 2020-04-15 16:29
 * @Description:
 */
public class Consumer2 {

    public static void main(String[] argv) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");


        // 打开连接和创建频道，与发送端一样
        Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();

        channel.exchangeDeclare(FanoutProducer.EXCHANGE_NAME,
                BuiltinExchangeType.FANOUT);
        // 声明一个随机队列
        String queueName = channel.queueDeclare().getQueue();

        //只关注error级别的日志，然后记录到文件中去
        String severity = "test";
        channel.queueBind(queueName, FanoutProducer.EXCHANGE_NAME,
                severity);

        System.out.println(" [*] Waiting for messages......");

        // 创建队列消费者
        final Consumer consumerB = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                //记录日志到文件：
                System.out.println("Received [" + envelope.getRoutingKey()
                        + "] " + message);
            }
        };
        channel.basicConsume(queueName, true, consumerB);
    }
}

通过测试表明，不管我们如何调整生产者和消费者的路由键，都对消息的接受没有影响。

3.Topic

通过使用“”和“#”，使来自不同源头的消息到达同一个队列，”.”将路由键分为了几个标识符，“”匹配1个，“#”匹配一个或多个。例如日志处理：
假设有交换器log-exchange，
日志级别有error,info,warning，
应用模块有user,order,email，
服务器有 A、B、C、D
路由键的规则为 日志级别+“.”+应用模块名+“.”+服务器，如：info.email.A。

  • 1、要关注A服务器发送的所有应用错误的消息，怎么做？
    声明队列名称为“a-app-error-queue”并绑定到交换器上：channel. queueBind (‘a-app-error-queue’,’logs-change’,’error.*.A’)
  • 2、关注B服务器发送的的所有日志，怎么办？
    声明队列名称为“b-all-queue”并绑定到交换器上：channel. queueBind (b-all-queue’,’logs-change’,’ #.B’)或channel. queueBind (b-all-queue’,’logs-change’,’ ..B’)
  • 3、关注所有服务器发送的email的所有日志，怎么办？
    声明队列名称为“email-all-queue”并绑定到交换器上：channel. queueBind (email -all-queue’,’logs-change’,’ .email.’)
  • 4、想要接收所有日志：channel->queue_bind(‘all-log’,’logs-change’,’#’)

TopicProducer

package exchange.topic;

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

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

/**
 *
 */
public class TopicProducer {

    public final static String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args)
            throws IOException, TimeoutException {
        /**
         * 创建连接连接到RabbitMQ
         */
        ConnectionFactory factory = new ConnectionFactory();
        // 设置MabbitMQ所在主机ip或者主机名
        factory.setHost("127.0.0.1");

        // 创建一个连接
        Connection connection = factory.newConnection();

        // 创建一个信道
        Channel channel = connection.createChannel();
        // 指定转发
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

        /*日志消息，路由键最终格式类似于：info.order.B*/
        String[] severities = {"error", "info", "warning"};
        for (int i = 0; i < 3; i++) {
            String[] modules = {"user", "order", "email"};
            for (int j = 0; j < 3; j++) {
                String[] servers = {"A", "B", "C"};
                for (int k = 0; k < 3; k++) {
                    // 发送的消息
                    String message = "Hello Topic_[" + i + "," + j + "," + k + "]";
                    String routeKey = severities[i % 3] + "." + modules[j % 3]
                            + "." + servers[k % 3];
                    channel.basicPublish(EXCHANGE_NAME, routeKey, null, message.getBytes());
                    System.out.println(" [x] Sent '" + routeKey + ":'"
                            + message + "'");
                }
            }

        }
        // 关闭频道和连接
        channel.close();
        connection.close();
    }

}

订阅所有消息

package exchange.topic;

import com.rabbitmq.client.*;

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

/**
 */
public class AllConsumer {

    public static void main(String[] argv) throws IOException,
            InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");

        // 打开连接和创建频道，与发送端一样
        Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();

        channel.exchangeDeclare(TopicProducer.EXCHANGE_NAME,
                BuiltinExchangeType.TOPIC);
        // 声明一个随机队列
        String queueName = channel.queueDeclare().getQueue();

        channel.queueBind(queueName,TopicProducer.EXCHANGE_NAME,
                "#");

        System.out.println(" [*] Waiting for messages:");

        // 创建队列消费者
        final Consumer consumerA = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" AllConsumer Received "
                        + envelope.getRoutingKey()
                        + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumerA);
    }
}

所有Email消息

package exchange.topic;

import com.rabbitmq.client.*;

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

/**
 *
 */
public class EmailAllConsumer {

    public static void main(String[] argv) throws IOException,
            InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");

        // 打开连接和创建频道，与发送端一样
        Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();

        channel.exchangeDeclare(TopicProducer.EXCHANGE_NAME,
                BuiltinExchangeType.TOPIC);
        // 声明一个随机队列
        String queueName = channel.queueDeclare().getQueue();

        channel.queueBind(queueName, TopicProducer.EXCHANGE_NAME, "*.email.*");

        System.out.println(" [*] Waiting for messages:");

        // 创建队列消费者
        final Consumer consumerA = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" AllConsumer Received "
                        + envelope.getRoutingKey()
                        + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumerA);
    }
}

所有错误日志消息

package exchange.topic;

import com.rabbitmq.client.*;

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

/**
 */
public class ErrorAllConsumer {

    public static void main(String[] argv) throws IOException,
            InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");

        // 打开连接和创建频道，与发送端一样
        Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();

        channel.exchangeDeclare(TopicProducer.EXCHANGE_NAME,
                BuiltinExchangeType.TOPIC);
        // 声明一个随机队列
        String queueName = channel.queueDeclare().getQueue();

        channel.queueBind(queueName, TopicProducer.EXCHANGE_NAME,
                "error.#");

        System.out.println(" [*] Waiting for messages:");

        // 创建队列消费者
        final Consumer consumerA = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" AllConsumer Received "
                        + envelope.getRoutingKey()
                        + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumerA);
    }
}

A发出的所有错误消息

package exchange.topic;

import com.rabbitmq.client.*;

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


public class ServerAErrorConsumer {

    public static void main(String[] argv) throws IOException,
            InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");

        // 打开连接和创建频道，与发送端一样
        Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();

        channel.exchangeDeclare(TopicProducer.EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        // 声明一个随机队列
        String queueName = channel.queueDeclare().getQueue();

        channel.queueBind(queueName, TopicProducer.EXCHANGE_NAME, "error.*.A");

        System.out.println(" [*] Waiting for messages:");

        // 创建队列消费者
        final Consumer consumerA = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" AllConsumer Received "
                        + envelope.getRoutingKey()
                        + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumerA);
    }
}

B发出的所有消息

package exchange.topic;

import com.rabbitmq.client.*;

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

/**
 *
 */
public class ServerBAllConsumer {

    public static void main(String[] argv) throws IOException,
            InterruptedException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");

        // 打开连接和创建频道，与发送端一样
        Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();

        channel.exchangeDeclare(TopicProducer.EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        // 声明一个随机队列
        String queueName = channel.queueDeclare().getQueue();

        channel.queueBind(queueName, TopicProducer.EXCHANGE_NAME, "#.B");

        System.out.println(" [*] Waiting for messages:");

        // 创建队列消费者
        final Consumer consumerA = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" AllConsumer Received "
                        + envelope.getRoutingKey()
                        + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumerA);
    }
}
清梦之灵
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【RabbitMQ】原生Java客户端进行消息通信
猫巳的博客
06-13 290
erlang v19.2rabbitmq_server v3.6.6 Direct参见代码no-spring模块包cn.enjoyedu.exchange.direct中： DirectProducer：direct类型交换器的生产者 NormalConsumer：普通的消费者 MulitBindConsumer：队列绑定到交换器...
RabbitMQ在java中的使用、整合
m0_73598900的博客
05-25 1398
学习RabbitMQ作为消息队列中间件，对于理解分布式系统、异步处理、应用解耦和提高系统可扩展性非常有帮助
RabbitMQ 3：原生Java客户端+Topic交换器+消息通信
Fisher3652的博客
05-04 245
1.创建生产者TopicProducer package com.rabbit.fisher.topic; import com.rabbitmq.client.BuiltinExchangeType; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq....
RabbitMQ初体验之原生java依赖的MQ
m0_58046039的博客
01-27 2866
1.什么是MQ 1.1MQ全称为Message Queue，即消息队列. 它也是一个队列,遵循FIFO原则 。RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue Protocol高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开 发中应用非常广泛。官方地址：http://www.rabbitmq.com/ 2.MQ的使用场景 2.1 解耦 消除峰值 服务调用异步 3.MQ的组成...
RabbitMQ 2：原生Java客户端+Fanout交换器+消息通信
Fisher3652的博客
05-03 187
1.创建生产者FanoutProducer package com.rabbit.fisher.fanout; import com.rabbitmq.client.BuiltinExchangeType; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitm...
RabbitMQ 1：原生Java客户端+Direct交换器+消息通信
Fisher3652的博客
05-02 300
1.maven工程引入amqp-client-5.0.0.jar <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.0.0</version> </depende...
RabbitMQ快速入门
风吟Pro的博客
11-26 1596
RabbitMQ快速入门 RabbitMQ整合Spring、SpringBoot
Kafka与RabbitMQ的区别
技术人集结地
01-08 2268
Apache Kafka是一个开源流处理平台，由Scala和Java编写，由Apache软件基金会开发。它是一个高吞吐量的分布式发布订阅消息系统，可以处理消费者在网站中的所有动作流数据。这些数据通常是由于吞吐量的要求而通过处理日志和日志聚合来解决。对于像Hadoop一样的日志数据和离线分析系统，但又要求实时处理的限制，Kafka是一个可行的解决方案。Kafka的目的是通过Hadoop的并行加载机制来统一线上和离线的消息处理，也是为了通过集群来提供实时的消息。
面试面经|Java面试RabbitMQ面试题
Q54665642ljf的博客
08-08 222
Java面试RabbitMQ面试题 凡事预则立，不预则废。能读到这里的人，我相信都是这个世界上的“有心人”，还是那句老话：上天不负有心人！我相信你的每一步努力，都会收获意想不到的回报。
[RabbitMQ]Java客户端：源码概览
gb4215287的博客
04-05 1157
本文简要介绍RabbitMQ提供的Java客户端中最基本的功能性接口/类及相关源码。 Mavan依赖： <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.13.1</version> </dependency> 0AMQP# co..
言讯IM即时聊天通讯软件双端原生源码后端JAVA
08-17
总而言之，【言讯IM即时聊天通讯软件双端原生源码后端JAVA】是一套完整的即时通讯解决方案，涵盖了客户端和服务器端的全部技术细节，为企业和开发者提供了构建高效、稳定、自定义的即时通讯系统的强大基础。...
RabbitMQ客户端连接池的原理及源码
04-18
3. **连接对象（Connection）**：RabbitMQ客户端与服务端的通信通道，通过它可以创建信道(Channel)进行实际的消息操作。 4. **对象池策略（Pooling Strategy）**：定义了连接的分配和回收规则，例如线程局部连接、...
Java相关知识总结，包括Java基础、MySQL、Springboot、MyBatis、Redis、RabbitMQ
10-15
RabbitMQ还支持多种语言的客户端，便于不同语言的应用进行通信。 综上所述，Java相关知识涵盖了广泛的领域，从基础语法到高级框架，再到数据库和消息队列的使用。掌握这些知识点，对于成为一个全面的Java开发者至关...
JAVA在线派单抢单平台系统 完整版本 原生安卓苹果APP
08-05
该在线派单抢单平台系统基于JAVA技术栈开发，提供了原生的安卓和苹果iOS应用，旨在实现高效、便捷的订单分配与接单流程。这个系统的核心功能可能包括订单发布、用户注册与登录、实时抢单通知、订单状态追踪、支付...
RabbitMQ3.9.13和ErLang24.2版本
02-24
4. **客户端库支持**：此版本的RabbitMQ继续兼容并优化了对多种编程语言的客户端库，如Java、Python、Ruby、.NET等，确保开发者可以方便地在各自的应用中集成RabbitMQ。 5. **监控和管理**：RabbitMQ 3.9.13提供了...
Prometheus 监控 RabbitMQ
TechEnthusiast的博客
07-24 475
RabbitMQ Exporter 是连接 RabbitMQ 和 Prometheus 的桥梁，它从 RabbitMQ 收集指标并以 Prometheus 可以理解的格式暴露这些指标。通过以上步骤，您可以建立一个全面的 RabbitMQ 监控系统，及时发现并解决潜在问题，确保消息中间件的稳定运行。记住，监控是一个持续的过程，需要根据系统的变化和需求不断调整和优化。注意：请根据您的 RabbitMQ 配置调整用户名、密码和 URL。修改 Prometheus 配置文件（通常是 ​。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 264
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1047
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Android 怎么使用RabbitMQ的Java客户端库
05-31
在Android中使用RabbitMQ的Java客户端库，需要进行以下几个步骤： 1. 添加RabbitMQ的Java客户端库到项目中。可以通过在项目的`build.gradle`文件中添加以下依赖来引入RabbitMQ的Java客户端库： ``` implementation...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值