rabbitmq 五种模型

最新推荐文章于 2024-07-24 12:14:21 发布
最新推荐文章于 2024-07-24 12:14:21 发布
阅读量834 收藏 3
点赞数
分类专栏： 消息中间件 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43589241/article/details/113725590
版权

文章目录

maven坐标

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.7.2</version>
</dependency>

在这里插入图片描述

简单的工具类


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

/**
 * @Author: czn
 * @Date 2021/2/6 14:46
 */
public class RabbitMQUtils {

    private static ConnectionFactory connectionFactory;

    static {
        connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.174.134");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/ems");
        connectionFactory.setUsername("ems");
        connectionFactory.setPassword("123");
    }
    public static Connection getConnection(){
        try {
            return connectionFactory.newConnection();
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

    public static void closeConnectionAndChanel(Channel channel,Connection conn){
        try {
            if (channel!=null) {
                channel.close();
            }
            if (conn!=null) {
                conn.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

1 简单队列/HelloWorld模式

一个生产者对应一个消费者

在这里插入图片描述

1.1生产者


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.Test;

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


public class Provider {

    @Test
    public void testSendMessage() throws IOException, TimeoutException {

        //1.创建mq的连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq主机
        connectionFactory.setHost("192.168.174.134");
        //设置端口号
        connectionFactory.setPort(5672);
        //设置连接那个虚拟机
        connectionFactory.setVirtualHost("/ems");
        //设置访问虚拟主机的用户名和密码
        connectionFactory.setUsername("ems");
        connectionFactory.setPassword("123");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();

        //获取连接中的通道
        Channel channel = connection.createChannel();

        //通道绑定对应消息队列
        //参数1：队列名称，如果队列不存在自动创建
        //参数2：用来定义队列特性是否持久化
        //参数3：是否独占队列
        //参数4：是否在消费完成后自动删除队列
        channel.queueDeclare("hello", false, false, false, null);

        //发布消息
        //参数1：交换机名称
        //参数2：队列名称
        //参数3：传递消息额外设置
        //参数4：消息的具体内容
        channel.basicPublish("","hello",null,"emm".getBytes());
        channel.close();
        connection.close();


    }
}

1.2 消费者


import com.rabbitmq.client.*;

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


public class Customer {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建mq的连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置连接mq主机
        factory.setHost("192.168.174.134");
        //设置端口号
        factory.setPort(5672);
        //设置连接那个虚拟机
        factory.setVirtualHost("/ems");
        //设置访问虚拟主机的用户名和密码
        factory.setUsername("ems");
        factory.setPassword("123");

        //获取连接对象
        Connection connection = factory.newConnection();

        //获取连接中的通道
        Channel channel = connection.createChannel();

        //通道绑定
        channel.queueDeclare("hello", false, false, false, null);

        //消费消息
        //参数1:消费那个队列的消息，队列名称
        //参数2:开始消息的自动确认机制
        //参数3:消费时的回调接口
        channel.basicConsume("hello", true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(new String(body));
            }
        });

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

}

1.3 运行

在这里插入图片描述

2 work 模式

一个生产者对应多个消费者，但是一条消息只能有一个消费者获得消息

在这里插入图片描述

2.1轮询分配

2.1.1 生产者

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Provider {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();

        Channel channel = connection.createChannel();

        channel.queueDeclare("work",true,false,false,null);

        for (int i = 0 ; i < 20 ; i++){
            channel.basicPublish("","work",null,(i+"===>hello work queue").getBytes());
        }

        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }

}

2.1.2 消费者1

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

/**
 * @Author: czn
 * @Date 2021/2/6 16:57
 */
public class Costomer1 {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();

        Channel channel = connection.createChannel();

        channel.queueDeclare("work",true,false,false,null);

        channel.basicConsume("work",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1:"+new String(body));
            }
        });
    }
}

2.1.3消费者2

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Costomer2 {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();

        Channel channel = connection.createChannel();

        channel.queueDeclare("work",true,false,false,null);

        channel.basicConsume("work",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2:"+new String(body));
            }
        });
    }
}

2.1.4 运行

消费者1
在这里插入图片描述
消费者2
在这里插入图片描述

2.2 公平分配（能者多劳）

2.2.1 消费者1


import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

/**
 * @Author: czn
 * @Date 2021/2/6 16:57
 */
public class Costomer3 {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        final Channel channel = connection.createChannel();
        //每次只能消费一个消息
        channel.basicQos(1);
        channel.queueDeclare("work",true,false,false,null);
        //参数1:队列名
        // 参数2:消息自动确认 true 消费者自动向rabbitmq确认消息消费 false不会自动确认消息
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try{
                    Thread.sleep(2000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                System.out.println("消费者1:"+new String(body));
                //参数1:确认队列中那个具体消息
                // 参数2:是否开启多个消息同时确定
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

2.2.2 消费者4


import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

/**
 * @Author: czn
 * @Date 2021/2/6 16:57
 */
public class Costomer4 {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        final Channel channel = connection.createChannel();
        channel.basicQos(1);
        channel.queueDeclare("work",true,false,false,null);
        channel.basicConsume("work",false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者4:"+new String(body));
                //手动确认
                // 参数1:手动确认标识
                // 参数2:false 每次确认一个
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

2.2.3 生产者


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;

import java.io.IOException;

/**
 * @Author: czn
 * @Date 2021/2/6 16:50
 */
public class Provider {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("work",true,false,false,null);
        for (int i = 0 ; i < 20 ; i++){
            channel.basicPublish("","work",null,(i+"===>hello work queue").getBytes());
        }
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }

}

2.2.4 运行

消费者3（睡眠2s）
在这里插入图片描述

消费者4
在这里插入图片描述

3 fanout广播模式/发布/订阅模式

一个消费者将消息首先发送到交换器,交换器绑定多个队列,然后被监听该队列的消费者所接收并消费.

在这里插入图片描述

3.1 生产者


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Provider {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        // 将通道声明指定交换机
        // 参数1:交换机名称 如果没有则自动创建
        // 参数2:交换机类型
        channel.exchangeDeclare("logs", "fanout");

        // 发消息
        channel.basicPublish("logs","",null,"fanout message".getBytes());

        //释放资源
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

3.2 消费者1,2,3


import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Costomer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        //通道绑定交换机
        channel.exchangeDeclare("logs","fanout");

        //绑定临时队列
        String queueName = channel.queueDeclare().getQueue();

        //绑定交换机和队列
        channel.queueBind(queueName,"logs","");

        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1: "+new String(body));
            }
        });

    }
}

3.3 运行

当生产者发布消息时,三个消费者都同时消费了
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4 Routing 路由模式

在Fanout模式中,一条消息,会被所有订阅的队列都消费。但是,在某些场景下,我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange.

在这里插入图片描述

4.1 生产者


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        // 参数1:交换机名称
        // 参数2:交换机类型
        channel.exchangeDeclare("logs_direct","direct");
        // 发送消息
        String routingKey = "warning";
        channel.basicPublish("logs_direct",routingKey,null,("direct模型 route key:["+routingKey+"]发送的消息").getBytes());
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

4.2 消费者1


import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Customer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        //声明交换机和交换机类型
        channel.exchangeDeclare("logs_direct","direct");
        //创建临时队列
        String queue = channel.queueDeclare().getQueue();
        //基于route key绑定队列和交换机
        channel.queueBind(queue,"logs_direct","error");
        //获取消费的消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1:"+new String(body));
            }
        });

    }
}

4.3 消费者2


import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Customer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        //声明交换机和交换机类型
        channel.exchangeDeclare("logs_direct","direct");
        //创建临时队列
        String queue = channel.queueDeclare().getQueue();
        //基于route key绑定队列和交换机
        channel.queueBind(queue,"logs_direct","info");
        channel.queueBind(queue,"logs_direct","error");
        channel.queueBind(queue,"logs_direct","warning");
        //获取消费的消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2:"+new String(body));
            }
        });

    }
}

4.4 运行

生产者分别运行 info,error,warning

消费者1
在这里插入图片描述
消费者2
在这里插入图片描述

5 Topic

Topic类型的Exchange与Direct相比,都是可以根据Routingkey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key的时候使用通配"符!这种模型Routingkey一般都是由一个或多个单词组成,3个单词之间以.分割,例如: item.insert

  • 符号#: 表示匹配一个或多个词,
  • 符号*: 表示匹配一个词.

在这里插入图片描述

5.1 生产者

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import utils.RabbitMQUtils;

import java.io.IOException;

public class Provider {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("topics","topic");
        //发布消息
        String routekey = "user.save.delete";
        channel.basicPublish("topics",routekey,null,("topic动态路由["+routekey+"]").getBytes());

        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

5.2 消费者1


import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;


public class Customer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("topics","topic");
        //创建临时队列
        String queue = channel.queueDeclare().getQueue();
        //绑定队列及交换机
        channel.queueBind(queue,"topics","user.*");

        //消费消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1:"+new String(body));
            }
        });
    }
}

5.3 消费者2


import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

/**
 * @Author: czn
 * @Date 2021/2/7 11:11
 */
public class Customer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("topics","topic");
        //创建临时队列
        String queue = channel.queueDeclare().getQueue();
        //绑定队列及交换机
        channel.queueBind(queue,"topics","user.#");

        //消费消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2:"+new String(body));
            }
        });
    }
}

5.4 运行

生产者分别运行 user.sava.delete , user.save

消费者1
在这里插入图片描述
消费者2
在这里插入图片描述

CenZn
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbitmq常用的五种模型
weixin_45967375的博客
04-09 8053
第一种：Hello World 第二种：Work queues 第三种：Publish/Subscribe 第四种：Routing 第五种：Topics
rabbitMQ五种消息模型
weixin_45099622的博客
08-06 4287
rabbitMQ提供了6种消息模型，但是第六种其实是RPC(远程过程调用)，并不是MQ，所以是5种模式。 其中5种消息模型分为两类： 第一种和第二种是点对点 第三，四，五种是一对多，都属于订阅模型，只不过是进行路由的方式不同。 第六种RPC远程调用也可不算做模式 本文参照网站：https://www.rabbitmq.com/getstarted.html 一，一对一简单模式 概念 生产者将消息发送到“ hello”队列。使用者从该队列接收消息。 图解 “ P”是我们的生产者 “
rabbitmq五种消息模型
qq_38905668的博客
04-25 2093
交换机负责接收消息并根据消息的路由键将消息路由到一个或多个队列。消息持久化是RabbitMQ中的另一个重要特性，它确保消息、队列和交换机在服务器重启后依然存在。- 适用于复杂的消息路由场景，如根据不同的话题或事件类型路由消息。- 消息发送到交换机，交换机将消息发送到所有绑定的队列。- 生产者将消息发送到队列，消费者从队列中获取消息。- 每个消费者有自己的队列，都能接收到所有消息。- 适用于需要将不同消息路由到不同队列的场景。- 队列是存储消息的缓冲区，可以缓存消息。- 队列可以使用通配符订阅感兴趣的消息。
中间件_RabbitMQ五种消息模型
故常无，欲以观其妙；常有，欲以观其徼；
05-18 3314
RabbitMQ 提供了5种常用消息模型。但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。
RabbitMq的五大消息模型及Java代码演示
Aa5107033的博客
06-27 1461
主要介绍RabbitMq的五大消息模型，并通过代码实现各个订阅模型的使用
SpringCloud系列（十一）[MQ 篇] - 详述 RabbitMQ 五种模型的结构及具体实现
Fug_Lee的博客
02-08 754
详述 RabbitMQ 五种模型的结构及具体实现.
RabbitMQ 五种消息模型
凉快
04-09 4336
1、基本模型 一个发送者，一个队列，一个消费者 2、工作模型 一个发送者，一个列队，多个消费者 3、发布订阅模式之fanout 此时，就有交换机的事了。 这种模式，交换机和列队直接绑定，不需要指定routingkey，所以他的消息传输速度是发布订阅模式中最快的。 注意：其实之前的两种模式（基本模式和工作模式），也都是把消息发送给交换机，但是由于队列只有一个，而且我...
RabbitMQ的五种常见消费模型
热门推荐
唯有努力，方可自信！
10-12 1万+
在RabbitMQ中，消息的生产和消费是通过一系列的消费模型来管理的。本文将深入介绍RabbitMQ的五种常见消费模型，包括简单队列模型、工作队列模型、发布/订阅模型、路由模型和主题模型，在这种模型中，交换机会将消息路由到与它所绑定的队列匹配的路由键的队列中。如果有消息时，所有的消费者都会在接收到该消息后进行同样的处理，无法根据具体情况进行消息的划分，而且消息被平均分配，不能根据消息的重要性和紧急性进行处理。需要根据消息内容的模式将消息路由到不同队列的应用程序，例如按标签或关键字分发和处理不同的任务。
RabbitMQ五种消息模型
qq_18398239的博客
05-14 2010
RabbitMQ 官网： http://www.rabbitmq.com/ 官方教程：http://www.rabbitmq.com/getstarted.html 官网下载地址：http://www.rabbitmq.com/download.html Erlang下载地址：http://www.erlang.org/download.html 六种种消息模型 3、4、5这三种都属于订阅模型，只不过进行路由的方式不同： Exchange（交换机）：生产者将消息发送到交换器，交换器根据路由规则将消息路由一个
RabbitMQ常用五种模型
weixin_38635565的博客
04-24 910
1、引入rabbitmq的客户端jar包 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.6.0</version> </dependency> 2、rabbitmq的模型 第一种模型直连（直连） P:生产者，发送消息的程序； C：消费者，消...
rabbitmq五种工作模式应用场景
GY4396的博客
05-07 1577
** rabbitmq的五种工作模式 ** 简单模式 1个生产者将消息交给默认的交换机(AMQP default) 2 交换机获取消息后交给绑定这个生产者的队列(关系是通过队列名称完成) 3 监听当前队列的消费者获取消息,执行消费逻辑 应用场景:短信,聊天 场景：有一个oa系统，用户通过接收手机验证码进行注册，页面上点击获取验证码后，将验证码放到消息队列，然后短信服务从队列中获取到验证码，并发送给用户 工作模式(轮询) 1 生产者将消息交个交换机 2 交换机交给绑定的队列 3 队列由多个消费者同时监听,
rabbitMq 5种消息模型测试代码
07-18
rabbitMq 5种消息模型测试代码
RabbitMQ五种模式
07-01
异步调用的一种实现方式是引入MQ，A将调用信息发到消息中间件，然后B从消息中间件获取到消息内容执行。此时A不再需要等待B。 这个前提下，**就可以实现异步调用**，**冗余存储**（指可以在MQ中多存一些数据，等待B...
Springboo整合RabbitMQ并测试五种模型
12-02
在本文中，我们将深入探讨如何将Spring Boot与RabbitMQ集成，并通过实践了解五种不同的消息模型。首先，让我们简要介绍一下Spring Boot和RabbitMQ。 Spring Boot是Spring框架的一个微服务开发工具，它简化了配置，...
Python实现RabbitMQ6种消息模型的示例代码
09-17
#### 五、其他四种模型简介 除了以上两种模型外，RabbitMQ 还提供了以下四种模型，这些模型的实现原理和示例代码将在后续部分进一步阐述： 1. **发布/订阅模型**：支持一对多的发布者-订阅者关系。 2. **路由模型*...
【高级应用篇】深入Spring Boot与RabbitMQ：构建可靠的微服务通信
weixin_68020300的博客
07-24 1895
在微服务架构中，消息队列作为异步通信与服务解耦的关键组件，发挥着不可替代的作用。本文详尽探索RabbitMQ的高级特性，包括消息确认、持久化、优先级、死信队列、TTL以及发布确认机制，展示如何利用这些特性增强Spring Boot应用与RabbitMQ的集成，实现更高效、更稳健的微服务通信。通过讲解高级消息模式如发布/订阅、路由与主题，以及性能调优、安全性和常见问题的解决方案，本文旨在为开发者提供全面的指南，帮助他们掌握RabbitMQ在实际项目中的高级应用技巧。
QT5 FTP 客户端 实现多文件下载 上传
08-01
QT5 FTP 客户端 实现多文件下载 上传
MATLAB车牌识别实现车牌定位仿真系统（可运行）
08-01
车牌定位分为以下步骤： 图像预处理：读取图像并对其进行预处理，例如灰度化、降噪和增强等。 车牌区域定位：使用图像处理技术，例如边缘检测、连通区域检测和形态学操作等，找到车牌的大致位置。 车牌区域精确定位：通过进一步的图像处理技术，例如投影、边缘检测和形态学操作等，对车牌区域进行精确定位。 字符分割：将车牌区域中的字符进行分割，形成单独的字符图像。 字符识别：使用字符识别算法，例如模板匹配、神经网络或支持向量机等，对分割的字符进行识别。 本设计非常适合新手学习使用，进阶研究等二次开发。欢迎大家多多下载交流学习研究。
年度销售回款计划表（依据项目回款率制定，月度分解.xlsx
最新发布
08-01
销售统计，调查问卷，库存明细，跟进表，业绩统计表，差异分析 ，产品清单 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
rabbitmq 五种消息模型
08-18
RabbitMQ 支持以下五种消息模型： 1. Simple Queue（简单队列）：消息生产者将消息发送到一个队列，然后消费者从队列中接收消息。这是最简单的消息模型，适用于一个生产者和一个消费者的场景。 2. Work Queue...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值