RabbitMQ（2）

最新推荐文章于 2022-05-17 14:39:43 发布
最新推荐文章于 2022-05-17 14:39:43 发布
阅读量169 收藏
点赞数
分类专栏： RabbitMQ

在AMQP模型中，Exchange是接受生产者消息并将消息路由到消息队列的关键组件。ExchangeType和Binding决定了消息的路由规则。所以生产者想要发送消息，首先必须要声明一个Exchange和该Exchange对应的Binding。可以通过 ExchangeDeclare和BindingDeclare完成。在Rabbit MQ中，声明一个Exchange需要三个参数：ExchangeName，ExchangeType和Durable。ExchangeName是该Exchange的名字，该属性在创建Binding和生产者通过publish推送消息时需要指定。ExchangeType，指Exchange的类型，在RabbitMQ中，有三种类型的Exchange：direct ，fanout和topic，不同的Exchange会表现出不同路由行为。Durable是该Exchange的持久化属性，这个会在消息持久化章节讨论。声明一个Binding需要提供一个QueueName，ExchangeName和BindingKey。下面我们就分析一下不同的ExchangeType表现出的不同路由规则。

a)   如果是  Fanout  类型，则会将消息发送给所有与该  Exchange  定义过  Binding  的所有  Queues  中去，其实是一种广播行为。

b) 如果是Direct类型，则会将消息中的RoutingKey与该Exchange关联的所有Binding中的BindingKey进行比较，如果相等，则发送到该Binding对应的Queue中。

c)如果是Topic类型，则会按照正则表达式，对RoutingKey与BindingKey进行匹配，如果匹配成功，则发送到对应的Queue中。

一：Fanout  

在上一篇说到的队列都指定了名称，但是现在我们不需要这么做，我们需要所有的日志信息，而不只是其中的一个。如果要做这样的队列，我们需要2件事，一个就是获取一个新的空的队列，这样我就需要创建一个随机名称的队列，最好让服务器帮我们做出选择，第一个就是我们断开用户的队列，应该自动进行删除。ok下面是一副工作图。

package common.rabbitMQ;

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

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

public class EmitLog {
	private static final String EXCHANGE_NAME = "logs";

	public static void main(String[] args) throws IOException, TimeoutException {
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("localhost");
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();

		channel.exchangeDeclare(EXCHANGE_NAME, "fanout");// fanout表示分发，所有的消费者得到同样的队列信息
		// 分发信息
		for (int i = 0; i < 5; i++) {
			String message = "Hello World" + i;
			channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
			System.out.println("EmitLog Sent '" + message + "'");
		}
		channel.close();
		connection.close();
	}
}
package common.rabbitMQ;

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

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class ReceiveLogs1 {
    private static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        //产生一个随机的队列名称
        String queueName = channel.queueDeclare().getQueue();
        channel.queueBind(queueName, EXCHANGE_NAME, "");//对队列进行绑定

        System.out.println("ReceiveLogs1 Waiting for messages");
        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("ReceiveLogs1 Received '" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumer);//队列会自动删除
    }
}

 

 

二：Direct

上面我用采用了广播的模式进行消息的发送，现在我们采用路由的方式对不同的消息进行过滤

发送端代码

package common.rabbitMQ;

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

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

public class RoutingSendDirect {
    private static final String EXCHANGE_NAME = "direct_logs";
    // 路由关键字
    private static final String[] routingKeys = new String[]{"info" ,"warning", "error"};
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");//注意是direct
        //发送信息
        for (String routingKey:routingKeys){
            String message = "RoutingSendDirect Send the message level:" + routingKey;
            channel.basicPublish(EXCHANGE_NAME,routingKey,null,message.getBytes());
            System.out.println("RoutingSendDirect Send"+routingKey +"':'" + message);
        }
        channel.close();
        connection.close();
    }
}
package common.rabbitMQ;

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

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class ReceiveLogsDirect1 {
	// 交换器名称
	private static final String EXCHANGE_NAME = "direct_logs";
	// 路由关键字
	private static final String[] routingKeys = new String[] { "info", "warning" };

	public static void main(String[] args) throws IOException, TimeoutException {
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("localhost");
		Connection connection = factory.newConnection();
		Channel channel = connection.createChannel();
		// 声明交换器
		channel.exchangeDeclare(EXCHANGE_NAME, "direct");
		// 获取匿名队列名称
		String queueName = channel.queueDeclare().getQueue();

		// 根据路由关键字进行绑定
		for (String routingKey : routingKeys) {
			channel.queueBind(queueName, EXCHANGE_NAME, routingKey);
			System.out.println("ReceiveLogsDirect1 exchange:" + EXCHANGE_NAME + "," + " queue:" + queueName
					+ ", BindRoutingKey:" + routingKey);
		}
		System.out.println("ReceiveLogsDirect1  Waiting for messages");
		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("ReceiveLogsDirect1 Received '" + envelope.getRoutingKey() + "':'" + message + "'");
			}
		};
		channel.basicConsume(queueName, true, consumer);
	}
}
package common.rabbitMQ;

import java.io.UnsupportedEncodingException;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class ReceiveLogsDirect2 {
    // 交换器名称
    private static final String EXCHANGE_NAME = "direct_logs";
    // 路由关键字
    private static final String[] routingKeys = new String[]{"error"};

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        //声明交换器
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //获取匿名队列名称
        String queueName = channel.queueDeclare().getQueue();
        //根据路由关键字进行多重绑定
        for (String severity : routingKeys) {
            channel.queueBind(queueName, EXCHANGE_NAME, severity);
            System.out.println("ReceiveLogsDirect2 exchange:"+EXCHANGE_NAME+", queue:"+queueName+", BindRoutingKey:" + severity);
        }
        System.out.println("ReceiveLogsDirect2 Waiting for messages");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws UnsupportedEncodingException {
                String message = new String(body, "UTF-8");
                System.out.println("ReceiveLogsDirect2 Received '" + envelope.getRoutingKey() + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumer);
    }
}

上面代码可以看出这里是通过路由来找个这个对列的。我们看下结果

RoutingSendDirect Sendinfo':'RoutingSendDirect Send the message level:info
RoutingSendDirect Sendwarning':'RoutingSendDirect Send the message level:warning
RoutingSendDirect Senderror':'RoutingSendDirect Send the message level:error
ReceiveLogsDirect1 exchange:direct_logs, queue:amq.gen-xYnnDxZjmZGbvV2CZi8CkQ, BindRoutingKey:info
ReceiveLogsDirect1 exchange:direct_logs, queue:amq.gen-xYnnDxZjmZGbvV2CZi8CkQ, BindRoutingKey:warning
ReceiveLogsDirect1  Waiting for messages
ReceiveLogsDirect1 Received 'info':'RoutingSendDirect Send the message level:info'
ReceiveLogsDirect1 Received 'warning':'RoutingSendDirect Send the message level:warning'

 

ReceiveLogsDirect2 exchange:direct_logs, queue:amq.gen-zPaGY_H3rCKMlVsSv2RowQ, BindRoutingKey:error
ReceiveLogsDirect2 Waiting for messages
ReceiveLogsDirect2 Received 'error':'RoutingSendDirect Send the message level:error'

 

三：Topic

这种应该属于模糊匹配

* ：可以替代一个词

#：可以替代0或者更多的词

现在我们继续看看代码来理解

package common.rabbitMQ;

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

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

public class TopicSend {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = null;
        Channel channel = null;
        try{
            ConnectionFactory factory=new ConnectionFactory();
            factory.setHost("localhost");
            connection=factory.newConnection();
            channel=connection.createChannel();

            //声明一个匹配模式的交换机
            channel.exchangeDeclare(EXCHANGE_NAME,"topic");
            //待发送的消息
            String[] routingKeys=new String[]{
                    "quick.orange.rabbit",
                    "lazy.orange.elephant",
                    "quick.orange.fox",
                    "lazy.brown.fox",
                    "quick.brown.fox",
                    "quick.orange.male.rabbit",
                    "lazy.orange.male.rabbit"
            };
            //发送消息
            for(String severity :routingKeys){
                String message = "From "+severity+" routingKey' s message!";
                channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes());
                System.out.println("TopicSend Sent '" + severity + "':'" + message + "'");
            }
        }catch (Exception e){
            e.printStackTrace();
            if (connection!=null){
                channel.close();
                connection.close();
            }
        }finally {
            if (connection!=null){
                channel.close();
                connection.close();
            }
        }
    }
}
package common.rabbitMQ;

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

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class ReceiveLogsTopic1 {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        //声明一个匹配模式的交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        String queueName = channel.queueDeclare().getQueue();
        //路由关键字
        String[] routingKeys = new String[]{"*.orange.*"};
        //绑定路由
        for (String routingKey : routingKeys) {
            channel.queueBind(queueName, EXCHANGE_NAME, routingKey);
            System.out.println("ReceiveLogsTopic1 exchange:" + EXCHANGE_NAME + ", queue:" + queueName + ", BindRoutingKey:" + routingKey);
        }
        System.out.println("ReceiveLogsTopic1 Waiting for messages");

        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("ReceiveLogsTopic1 Received '" + envelope.getRoutingKey() + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumer);
    }
}
package common.rabbitMQ;

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

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

public class ReceiveLogsTopic2 {
    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] argv) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
//      声明一个匹配模式的交换器
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        String queueName = channel.queueDeclare().getQueue();
        // 路由关键字
        String[] routingKeys = new String[]{"*.*.rabbit", "lazy.#"};
//      绑定路由关键字
        for (String bindingKey : routingKeys) {
            channel.queueBind(queueName, EXCHANGE_NAME, bindingKey);
            System.out.println("ReceiveLogsTopic2 exchange:"+EXCHANGE_NAME+", queue:"+queueName+", BindRoutingKey:" + bindingKey);
        }

        System.out.println("ReceiveLogsTopic2 Waiting for messages");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws UnsupportedEncodingException  {
                String message = new String(body, "UTF-8");
                System.out.println("ReceiveLogsTopic2 Received '" + envelope.getRoutingKey() + "':'" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumer);
    }
}

看下结果 ：

TopicSend Sent 'quick.orange.rabbit':'From quick.orange.rabbit routingKey' s message!'
TopicSend Sent 'lazy.orange.elephant':'From lazy.orange.elephant routingKey' s message!'
TopicSend Sent 'quick.orange.fox':'From quick.orange.fox routingKey' s message!'
TopicSend Sent 'lazy.brown.fox':'From lazy.brown.fox routingKey' s message!'
TopicSend Sent 'quick.brown.fox':'From quick.brown.fox routingKey' s message!'
TopicSend Sent 'quick.orange.male.rabbit':'From quick.orange.male.rabbit routingKey' s message!'
TopicSend Sent 'lazy.orange.male.rabbit':'From lazy.orange.male.rabbit routingKey' s message!'
ReceiveLogsTopic1 exchange:topic_logs, queue:amq.gen-v_5leE4IrQ1NAb8cezJpBA, BindRoutingKey:*.orange.*
ReceiveLogsTopic1 Waiting for messages
ReceiveLogsTopic1 Received 'quick.orange.rabbit':'From quick.orange.rabbit routingKey' s message!'
ReceiveLogsTopic1 Received 'lazy.orange.elephant':'From lazy.orange.elephant routingKey' s message!'
ReceiveLogsTopic1 Received 'quick.orange.fox':'From quick.orange.fox routingKey' s message!'
ReceiveLogsTopic2 exchange:topic_logs, queue:amq.gen-9EC2ktkkUxRy9xBMBcYFkg, BindRoutingKey:*.*.rabbit
ReceiveLogsTopic2 exchange:topic_logs, queue:amq.gen-9EC2ktkkUxRy9xBMBcYFkg, BindRoutingKey:lazy.#
ReceiveLogsTopic2 Waiting for messages
ReceiveLogsTopic2 Received 'quick.orange.rabbit':'From quick.orange.rabbit routingKey' s message!'
ReceiveLogsTopic2 Received 'lazy.orange.elephant':'From lazy.orange.elephant routingKey' s message!'
ReceiveLogsTopic2 Received 'lazy.brown.fox':'From lazy.brown.fox routingKey' s message!'
ReceiveLogsTopic2 Received 'lazy.orange.male.rabbit':'From lazy.orange.male.rabbit routingKey' s message!'

Broker：简单来说就是消息队列服务器实体。
Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列。
Queue：消息队列载体，每个消息都会被投入到一个或多个队列。
Binding：绑定，它的作用就是把exchange和queue按照路由规则绑定起来。
Routing Key：路由关键字，exchange根据这个关键字进行消息投递。
vhost：虚拟主机，一个broker里可以开设多个vhost，用作不同用户的权限分离。
producer：消息生产者，就是投递消息的程序。
consumer：消息消费者，就是接受消息的程序。
channel：消息通道，在客户端的每个连接里，可建立多个channel，每个channel代表一个会话任务。

qq_37211608
关注
专栏目录
搭建高可用 RabbitMQ 集群和 HAProxy 软负载
weixin_44767040的博客
06-28 1232
搭建高可用 RabbitMQ 集群和 HAProxy 软负载
rabbitmq消息持久化
luuJa_IQ的博客
02-20 382
RabbitMQ支持消息的持久化，也就是数据写在磁盘上，为了数据安全考虑，我想大多数用户都会选择持久化。消息队列持久化包括3个部分： 1、exchange持久化，在声明时指定durable => 1 2、queue持久化，在声明时指定durable => 1 3、消息持久化，在投递时指定delivery_mode => 2（1是非持久化） 如果exchange和queue都是持久...
RabbitMQ中 exchange、route、queue的关系
草根上的须子
05-17 2925
从AMQP协议可以看出，MessageQueue、Exchange和Binding构成了AMQP协议的核心，下面我们就围绕这三个主要组件 从应用使用的角度全面的介绍如何利用Rabbit MQ构建消息队列以及使用过程中的注意事项。 1.声明MessageQueue 在Rabbit MQ中，无论是生产者发送消息还是消费者接受消息，都首先需要声明一个MessageQueue。这就存在一个问题，是生产者声明还是消费者声明呢？要解决这个问题，首先需要明确： a)消费者是无法...
RabbitMQ之Exchange、Queue参数详解
热门推荐
dh554112075的博客
05-13 1万+
1.先来介绍RabbitMQ中的成员 Producer(生产者)： 将消息发送到Exchange Exchange(交换器)：将从生产者接收到的消息路由到Queue Queue(队列)：存放供消费者消费的消息 BindingKey(绑定键)：建立Exchange与Queue之间的关系（个人看作是一种规则，也就是Exchange将什么样的消息路由到Queue） RoutingKey(路由键)：Pr...
rabbitmq 消息队列queue exchange声明实现
thatkrisyang
09-08 2243
1 注解实现 @RabbitHandler @RabbitListener(containerFactory = “rabbitListenerContainerFactory”, bindings=@QueueBinding( value=@Queue(value = “${mall.shop.interactiveMsg.topic}”, durable = “true”...
channel.exchangeDeclare方法介绍
小城我家
05-29 7895
exchangeDeclare /** * Declare an exchange. * @see com.rabbitmq.client.AMQP.Exchange.Declare * @see com.rabbitmq.client.AMQP.Exchange.DeclareOk * @param exchange the name of the ex...
RabbitMQ的ack机制
sangjunhong的博客
04-13 8079
1、什么是消息确认ACK。 答：如果在处理消息的过程中，消费者的服务器在处理消息的时候出现异常，那么可能这条正在处理的消息就没有完成消息消费，数据就会丢失。为了确保数据不会丢失，RabbitMQ支持消息确定-ACK。 2、RabbitMQ的ACK的消息确认机制。 ACK机制是消费者从RabbitMQ收到消息并处理完成后，反馈给RabbitMQ，MQ收到反馈后才将此消息从队列中删除。消息的ACK确认机制默认是打开的。 如果一个消费者在处理消息出现了网络不稳、服务器异常等现象，那么就不会有ACK反馈，Rabbi
RabbitMQ Server3.13.0
04-02
OTP_win64_26.2.2 是Erlang在Windows 64位平台上的版本，是运行RabbitMQ Server所必需的，因为RabbitMQ是用Erlang编写的。 **安装与配置** 1. **下载与安装Erlang**: 在安装RabbitMQ之前，首先需要下载并安装...
RabbitMQ
05-01
2. **集群配置**: 配置RabbitMQ集群可以提高可用性和性能。通过增加节点，负载可以分散，同时提供冗余以防止单点故障。 3. **内存管理**: 监控和调整RabbitMQ的内存使用，避免因内存过高导致的性能下降或服务中断。...
RabbitMQ镜像文件
02-27
RabbitMQ镜像文件
kettle rabbitmq 插件开发
10-26
2. **Kettle 简介**：理解 Kettle 的工作原理，如作业（Job）和转换（Transformation），以及它们如何处理数据流。 3. **Kettle 插件开发**：Kettle 支持自定义插件开发，这通常是通过 Java 进行的。开发者需要熟悉...
exchangeDeclare方法详解
Jayce的博客
10-24 7247
exchangeDeclare有多个重载方法，这些方法都是由下面这个方法中的缺省参数构成的。 Exchange.DeclareOk exchangeDeclare(String exchange,String type,boolean durable,boolean autoDelete,boolean internal,Map<String,Object> arguments) t...
RabbitMq的学习（三）：Java使用Exchange（路由）
LemonCake的博客
11-08 1998
RabbitMq的Exchange（路由）官方文档：http://www.rabbitmq.com/getstarted.html（语言记得选Java） 路由概要说明：一个Exchange（路由）可以绑定多个Queue（队列）， 根据不同的Exchange类型可以实现不同Exchange策略。   一、fanout 说明：把所有发送到该Exchange的消息路由到所有与它绑定的Queue...
Exchange几种交换机类型
qq_42856647的博客
04-04 6526
Exchange交换机 Exchange:接收消息，并根据路由键转发消息锁绑定的队列 交换机属性 Type:direct、topic、 fanout、headers Durability：是否需要持久化、true为持久化 Auto Delete：当最后一个绑定到Exchange上的队列删除后，自动删除该exchange Internal: 当前exchange 是否用于Rabbi...
ARCore（Android的增强现实）：ARCore性能优化与调试技巧.docx
最新发布
11-01
ARCore（Android的增强现实）：ARCore性能优化与调试技巧
停止维护 基于 ReactNative、Redux 的漫画.zip
11-01
停止维护 基于 ReactNative、Redux 的漫画
HIKVISION海康威视DS-7916N-E4 DS-7932N-E4录像机固件V3.4.106 build 200619
11-01
HIKVISION海康威视DS-7916N-E4 DS-7932N-E4硬盘录像机固件V3.4.106 build 200619版（2020年6月22日发布） 新版固件支持解绑萤石云功能。 注意： 设备升级有风险，请确认是否一定要升级设备。 请确认升级程序包是否适用于您的设备。 在设备升级过程中请勿断电。
2001-2023年上市公司企业平台生态嵌入数据含原始数据+计算代码+计算结果-最新出炉.zip
11-01
2001-2023年上市公司企业平台生态嵌入数据含原始数据+计算代码+计算结果-最新出炉.zip
基于SSM的四六级在线考试系统.zip
11-01
基于SSM的毕业设计源码
rabbitmq koa2
08-13
RabbitMQ 和 Koa2 是两个不同的技术栈，但它们可以很好地结合在一起使用，提供异步消息队列处理能力，增强Node.js应用的性能。 1. RabbitMQ：这是一个开源的消息代理，用于在分布式系统中发布/订阅消息模型。它允许...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值