002 JavaClent操作RabbitMQ

已于 2024-09-11 17:35:26 修改
阅读量368 收藏 8
点赞数 4
分类专栏： 中间件 # RabbitMQ 文章标签： rabbitmq java-rabbitmq 中间件
于 2024-09-11 17:34:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54158370/article/details/142145692
版权

Java Client操作RabbitMQ

文章目录

1.pom依赖

<!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.20.0</version>
</dependency>

2.连接工具类

/**
 * rabbitmq连接工具类
 * @author moshangshang
 */
@Slf4j
public class RabbitMQUtil {

    private static final String HOST_ADDRESS="192.168.1.102";
    private static final Integer PORT=5672;
    private static final String VIRTUAL_HOST="my_vhost";
    private static final String USER_NAME="root";
    private static final String PASSWORD="root";

    public static Connection getConnection() throws Exception {
        com.rabbitmq.client.ConnectionFactory factory=new com.rabbitmq.client.ConnectionFactory();
        factory.setHost(HOST_ADDRESS);
        factory.setPort(PORT);
        factory.setVirtualHost(VIRTUAL_HOST);
        factory.setUsername(USER_NAME);
        factory.setPassword(PASSWORD);
        return factory.newConnection();
    }

    public static void main(String[] args) {
        Connection connection = null;
        try {
            connection = getConnection();
        } catch (Exception e) {
            log.error("get rabbitmq connection exception....",e);
        }finally {
            try {
                if(connection!=null){
                    connection.close();
                }
            } catch (IOException e) {
                log.error("close rabbitmq connection exception....",e);
            }
        }
    }

}

3.简单模式

生产者投递消费到队列进行消费

在这里插入图片描述

消息发送

public class Send {

    private final static String QUEUE_NAME = "hello";


    public static void main(String[] argv) throws Exception {
        Connection connection = RabbitMQUtil.getConnection();
        try (Channel channel = connection.createChannel()) {
            //声明队列
            /*
             *  如果队列不存在，则会创建
             *  Rabbitmq不允许创建两个相同的队列名称，否则会报错。
             *
             *  @params1： queue 队列的名称
             *  @params2： durable 队列是否持久化
             *  @params3： exclusive 是否排他，即是否私有的，如果为true,会对当前队列加锁，其他的通道不能访问，并且连接自动关闭
             *  @params4： autoDelete 是否自动删除，当最后一个消费者断开连接之后是否自动删除消息。
             *  @params5： arguments 可以设置队列附加参数，设置队列的有效期，消息的最大长度，队列的消息生命周期等等。
             * */
            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 + "'");
        }
    }
}

消息接收

因为希望在消费者异步监听消息到达时，当前程序能够继续执行，而不是退出。

因为提供了一个DeliverCallback回调，该回调将缓冲消息，直到准备使用它们。

public class Recv {

  private final static String QUEUE_NAME = "hello";

  public static void main(String[] argv) throws Exception {
      Connection connection = RabbitMQUtil.getConnection();
      Channel channel = connection.createChannel();
      channel.queueDeclare(QUEUE_NAME, false, false, false, null);
      DeliverCallback deliverCallback = (consumerTag, delivery) -> {
          String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
          System.out.println(" [x] Received '" + message + "'");
      };
      channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
  }
}

4.工作队列模式（work）

生产者直接投递消息到队列，存在多个消费者情况

  • 创建一个工作队列，用于在多个工作人员之间分配耗时的任务。
  • 工作队列（又名：任务队列）背后的主要思想是避免立即执行资源密集型任务，并必须等待其完成。相反，我们把任务安排在以后完成。我们将任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当你运行多个worker时，任务将在它们之间共享。
  • 这个概念在web应用程序中特别有用，因为在短的HTTP请求窗口内无法处理复杂的任务。
  • 默认情况下，消费者会进行轮询调度
  • RabbitMQ支持消息确认。消费者发送回一个确认，告诉RabbitMQ已经收到、处理了一条特定的消息，RabbitMQ可以自由删除它。
  • 如果一个消费者在没有发送ack的情况下死亡（其通道关闭、连接关闭或TCP连接丢失），RabbitMQ将理解消息未完全处理，并将其重新排队。如果同时有其他消费者在线，它将迅速将其重新传递给另一个消费者。这样，即使worker偶尔挂掉，也可以确保没有信息丢失。
  • 消费者交付确认时强制执行超时（默认为30分钟）。这有助于检测一直没有确认的消费者。
  • 默认情况下，手动消息确认已打开。在前面的示例中，我们通过autoAck=true标志明确地关闭了它们。一旦我们完成了一项任务，是时候将此标志设置为false并从worker发送适当的确认了。

在这里插入图片描述

公平调度

由于默认轮询调度，有些任务执行时间长，有些短，所以会导致部分worker压力大

使用预取计数=1设置的basicQos方法。这条消息告诉RabbitMQ一次不要给一个worker发送多条消息。在处理并确认前一条消息之前，不要向worker发送新消息。相反，它会将其发送给下一个不忙的worker。

int prefetchCount = 1;
channel.basicQos(prefetchCount);

示例

public class WorkProvider {

  private static final String TASK_QUEUE_NAME = "work_queue";

  public static void main(String[] argv) throws Exception {
      Connection connection = RabbitMQUtil.getConnection();
      try (Channel channel = connection.createChannel()) {
        channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
          for (int i = 0; i < 8; i++) {
              String message = String.valueOf(i);
              channel.basicPublish("", TASK_QUEUE_NAME,
                      MessageProperties.PERSISTENT_TEXT_PLAIN,
                      message.getBytes(StandardCharsets.UTF_8));
              System.out.println(" 消息发送 ：'" + i + "'");
          }
    }
  }
}

public class WorkerConsumer1 {

  private static final String TASK_QUEUE_NAME = "work_queue";

  public static void main(String[] argv) throws Exception {
    final Connection connection = RabbitMQUtil.getConnection();
    final Channel channel = connection.createChannel();

    channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
    System.out.println(" 消息监听中。。。。。。");

    //控制ack流速,表示每次进行ack确认前只会处理一条消息
    //channel.basicQos(1);

    DeliverCallback deliverCallback = (consumerTag, delivery) -> {
        //获取消息
        String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
        System.out.println("worker1 消息消费：'" + message + "'");
        try {
            doWork(message);
        } finally {
            System.out.println(" 执行结束。。");
            //消息确认,根据消息序号(false只确认当前一个消息收到，true确认所有比当前序号小的消息（成功消费，消息从队列中删除 ）)
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    };
    //设置自动应答
    channel.basicConsume(TASK_QUEUE_NAME, false, deliverCallback, consumerTag -> { });
  }

}

消费者1的方法处理

  private static void doWork(String task) {
   
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignored) {
                Thread.currentThread().interrupt();
            }
      
  }

消费者2的方法处理

  private static void doWork(String task) {
      return;
  }

启动两个worker消费者，执行结果如下（轮询）：

在这里插入图片描述
在这里插入图片描述

若设置公平调度

channel.basicQos(1);

测试结果：

在这里插入图片描述
在这里插入图片描述

5.发布/订阅模式（fanout）

  • 不同于工作队列，同一消息在所有消费者共享，但只能有一个消费者消费，而发布订阅则会将同一消息发送给多个消费者，则将消息广播给所有订阅者

  • 在之前的模式中，都是直接将消息发送给队列，然后从队列消费，事实上之前使用了一个默认的交换机，即“”空字符串的

  • RabbitMQ消息传递模型的核心思想是生产者从不直接向队列发送任何消息。实际上，很多时候，生产者甚至根本不知道消息是否会被传递到任何队列。

  • 相反，生产者只能向exchange发送消息。exchange是一件非常简单的事情。它一方面接收来自生产者的消息，另一方面将它们推送到队列。exchange必须确切地知道如何处理它收到的消息。

在这里插入图片描述

将消息生产投递到exchange，由交换机去投递消息到队列

交换机

有几种exchange类型可供选择：direct、topic、headers和fanout。我们将专注于最后一个fanout。

//创建交换机名称为logs
channel.exchangeDeclare("logs", "fanout");

  /**
    * exchange：交换机的名称
    * type：交换机的类型
    * durable 队列是否持久化
    * autoDelete：是否自动删除，（当该交换机上绑定的最后一个队列解除绑定后，该交换机自动删除）
    * internal：是否是内置的，true表示内置交换器。（则无法直接发消息给内置交换机，只能通过其他交换机路由到该交换机）
    * argument：其他一些参数
    */
 channel.exchangeDeclare(EXCHANGE_NAME,"fanout",false,false,false,null);

第一个参数是exchange的名称。空字符串表示默认或未命名的交换：消息将被路由到routingKey指定名称的队列（如果存在）。

channel.basicPublish( "logs", "", null, message.getBytes());

绑定

我们已经创建了一个fanout交换机和一个队列。现在我们需要告诉exchange向我们的队列发送消息。交换和队列之间的关系称为绑定。

交换机会向绑定的队列通过路由key将消息路由到指定的队列中，fanout分发不需要路由key

在这里插入图片描述

//其中，第一个参数为绑定的队列，第二个参数为绑定的交换机，第三个参数为路由key
channel.queueBind(queueName, "logs", "");

#列出所有得绑定
rabbitmqctl list_bindings

示例代码

public class FanoutProvider {

    //声明交换机
    public static final String EXCHANGE_NAME="fanoutTest";
    //声明队列
    public static final String QUEUE_NAME1="queue_name1";
    public static final String QUEUE_NAME2="queue_name2";


    public static void main(String[] argv) throws Exception {
      Connection connection = RabbitMQUtil.getConnection();
      try (Channel channel = connection.createChannel()) {
          //声明交换机
          channel.exchangeDeclare(EXCHANGE_NAME,"fanout",false,false,false,null);
          //声明队列
          channel.queueDeclare(QUEUE_NAME1,false,false,false,null);
          channel.queueDeclare(QUEUE_NAME2,false,false,false,null);
          //进行队列绑定
          channel.queueBind(QUEUE_NAME1,EXCHANGE_NAME,"");
          channel.queueBind(QUEUE_NAME2,EXCHANGE_NAME,"");
          String message = "fanout模式消息推送。。。。。";
          //消息推送
          //参数说明：交换机，路由key/队列，消息属性，消息体
          channel.basicPublish(EXCHANGE_NAME, "", MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes(StandardCharsets.UTF_8));
          System.out.println(" 消息发送 ：'" +message + "'");
    }
  }

}

public class FanoutConsumer1 {

    public static final String EXCHANGE_NAME="fanoutTest";

    public static final String QUEUE_NAME1="queue_name1";

      public static void main(String[] argv) throws Exception {
          Connection connection = RabbitMQUtil.getConnection();
          //创建信道
          Channel channel = connection.createChannel();
          //声明交换机
          channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
          //绑定队列
          channel.queueBind(QUEUE_NAME1, EXCHANGE_NAME, "");
          DeliverCallback deliverCallback = (consumerTag, delivery) -> {
              String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
              System.out.println(" fanout 消费者1：'" + message + "'");
          };
          channel.basicConsume(QUEUE_NAME1, true, deliverCallback, consumerTag -> {});
      }

}

public class FanoutConsumer2 {

    public static final String EXCHANGE_NAME="fanoutTest";

    public static final String QUEUE_NAME2="queue_name2";

      public static void main(String[] argv) throws Exception {
          Connection connection = RabbitMQUtil.getConnection();
          //创建信道
          Channel channel = connection.createChannel();
          //声明交换机
          channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
          //绑定队列
          channel.queueBind(QUEUE_NAME2, EXCHANGE_NAME, "");
          DeliverCallback deliverCallback = (consumerTag, delivery) -> {
              String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
              System.out.println(" fanout 消费者2：'" + message + "'");
          };
          channel.basicConsume(QUEUE_NAME2, true, deliverCallback, consumerTag -> { });
      }

}

6.路由模式（direct）

由交换机通过路由key和绑定key进行消息推送，也可以将同一个路由key绑定到多个队列或所有队列，此时相当于fanout

如果推送消息的路由key不存在,则该消息会丢弃

public class DirectProvider {

    public static final String EXCHANGE_NAME="direct-exchange";
    public static final String QUEUE_NAME1="direct-queue";
    public static final String ROUTING_KEY="change:direct";

    public static void main(String[] argv) throws Exception {
      Connection connection = RabbitMQUtil.getConnection();
      try (Channel channel = connection.createChannel()) {
          //声明交换机
          channel.exchangeDeclare(EXCHANGE_NAME,"direct",false,false,false,null);
          //声明队列
          channel.queueDeclare(QUEUE_NAME1,false,false,false,null);
          String message = "direct模式消息推送。。。。。";
          //参数说明：交换机，路由key/队列，消息属性，消息体
          channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes(StandardCharsets.UTF_8));
          System.out.println(" 消息发送 ：'" +message + "'");
    }
  }

}

public class DirectConsumer {


    public static final String EXCHANGE_NAME="direct-exchange";
    public static final String QUEUE_NAME1="direct-queue";
    public static final String BINDING_KEY="change:direct";

      public static void main(String[] argv) throws Exception {
          Connection connection = RabbitMQUtil.getConnection();
          //创建信道
          Channel channel = connection.createChannel();
          //声明交换机
          channel.exchangeDeclare(EXCHANGE_NAME, "direct");
          //绑定队列
          channel.queueBind(QUEUE_NAME1, EXCHANGE_NAME, BINDING_KEY);
          DeliverCallback deliverCallback = (consumerTag, delivery) -> {
              String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
              System.out.println(" direct 消费者1：'" + message + "'");
          };
          channel.basicConsume(QUEUE_NAME1, true, deliverCallback, consumerTag -> { });
      }

}

7.Topic匹配模式

  • 发送到主题交换的消息不能有任意的路由key,它必须是一个由点分隔的单词列表。单词可以是任何东西，但通常它们指定了与消息相关的一些特征。一些有效的路由key示例：stock.usd.nyse、nyse.vmw、quick.orange.rabbit。路由密钥中可以有任意多的单词，最多255个字节。
  • 绑定key也必须采用相同的形式。topic交换机背后的逻辑类似于direct交换机，使用特定路由key发送的消息将被传递到所有使用绑定key绑定的所有队列。但是，绑定密钥有两个重要的特殊情况：
  • *（星号）只能代替一个单词。
  • #（hash）可以替代零个或多个单词。
public class TopicProvider {

    public static final String EXCHANGE_NAME="topic-exchange";
    public static final String QUEUE_NAME1="topic-queue";
    public static final String ROUTING_KEY="com.orange.test";
    public static final String ROUTING_KEY2="com.orange.test.aaa";

    public static void main(String[] argv) throws Exception {
      Connection connection = RabbitMQUtil.getConnection();
      try (Channel channel = connection.createChannel()) {
          //声明交换机
          channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC,false,false,false,null);
          //声明队列
          channel.queueDeclare(QUEUE_NAME1,false,false,false,null);
          String message1 = "topic test模式消息推送。。。。。";
          String message2 = "topic test.aaa模式消息推送。。。。。";
          //参数说明：交换机，路由key/队列，消息属性，消息体
          channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY, MessageProperties.PERSISTENT_TEXT_PLAIN, message1.getBytes(StandardCharsets.UTF_8));
          channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY2, MessageProperties.PERSISTENT_TEXT_PLAIN, message2.getBytes(StandardCharsets.UTF_8));
          System.out.println(" 消息发送 ：'" +message1 + "'");
          System.out.println(" 消息发送 ：'" +message2 + "'");
    }
  }

}

public class TopicConsumer {


    public static final String EXCHANGE_NAME="topic-exchange";
    public static final String QUEUE_NAME1="topic-queue";
    public static final String BINDING_KEY="*.orange.#";


      public static void main(String[] argv) throws Exception {
          Connection connection = RabbitMQUtil.getConnection();
          //创建信道
          Channel channel = connection.createChannel();
          //声明交换机
          channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
          //绑定队列
          channel.queueBind(QUEUE_NAME1, EXCHANGE_NAME, BINDING_KEY);
          DeliverCallback deliverCallback = (consumerTag, delivery) -> {
              String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
              System.out.println(" topic 消费者1：'" + message + "'");
          };
          channel.basicConsume(QUEUE_NAME1, true, deliverCallback, consumerTag -> { });
      }

}
陌殇殇
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA操作RabbitMQ
weixin_44080194的博客
09-08 3332
rabbitMQ的单机安装，常见的模型JAVA调用，springboot整合调用
Python操作rabbitMQ的示例代码
09-19
Python操作RabbitMQ是将Python编程语言与RabbitMQ消息中间件相结合，以实现应用程序间的高效、可靠的消息通信。RabbitMQ是一个基于AMQP（Advanced Message Queuing Protocol）的开源消息代理，它由Erlang语言开发，...
Django操作RabbitMQ
LoadingCreate的博客
06-19 2261
在本文中，我们介绍了如何在Django中使用RabbitMQ来发布和消费消息。RabbitMQ的强大功能和易于使用的API使得它成为了一个非常有用的工具，可以帮助应用程序处理大规模的并发请求。RabbitMQ提供了Windows、Linux和MacOS的软件包，因此你可以根据自己的操作系统下载相应的安装包。在这个例子中，我们使用了pika模块来建立与RabbitMQ的连接，并使用channel对象来发送消息到名为“hello”的队列中。一旦安装了RabbitMQ，我们就可以开始在Django中使用它了。
java操作RabbitMQ
热门推荐
卑微的小白
10-27 1万+
1、创建虚拟主机、交换机、队列 RabbitMQ提供了自己的管理界面，可以通过管理界面来完成VirtualHost、Exchange、queue的创建。 1.1创建VirtualHost 1.2创建交换机 创建交换机的时候需要指定虚拟主机以及交换机的类型（direct（路由模式）、fanout（广播）、headers、topic） direct：Exchange通过消息携带的路由键来将消息分发到对应的队列中 fanout：Exchange将消息分发到所有绑定到交换机的队列中 headers：Exchang
RabbitMQ基本操作
michael_linux的博客，一个小小小学生。滴水穿石，步步为营，只为那刹那芳华。
05-09 2839
1、linux安装rabbitmq 2、windows安装rabbitmq 3、rabbitMq相关名词概念 4、
rabbitMQ配置用户权限操作
道亦无名
02-17 3549
查看当前所有用户 rabbitmqctl list_users 添加帐号:name 密码:passwd rabbitmqctl add_user name passwd 赋予其administrator角色 rabbitmqctl set_user_tags name administrator 删除角色 rabbitmqctl delete_user Username 设置权限 rabbitmqctl set_permissions -p / name “." ".” “.*” 查看用户的权限 rabbi
C#操作RabbitMQ的完整实例
12-25
一、下载RabbitMQ http://www.rabbitmq.com/install-windows.html 二、下载OTP http://www.erlang.org/downloads 三、安装OTP、RabbitMQ 四、配置RabbitMQ 找到bat的目录 执行相关命令 1.添加用户密码 ...
【RabbitMQ】工作模式
weixin_73060900的博客
09-11 561
对RabbitMQ工作模式的简单概述以及代码案例
了解开源消息代理RabbitMQ
huaqianzkh的专栏
09-08 997
RabbitMQ是一个消息代理:它接受并转发消息。你可以把它想象成邮局:当你把要寄的邮件放进邮箱时，你可以确定邮递员最终会把邮件送到收件人那里。在这个比喻中，RabbitMQ是一个邮筒、一个邮局和一个邮递员。RabbitMQ和邮局之间的主要区别在于，它不处理纸张，而是接受、存储和转发二进制数据消息。RabbitMQ和一般的消息传递使用了一些术语。生产只不过意味着发送。发送消息的程序是是RabbitMQ中邮箱的名称。虽然消息流经RabbitMQ和你的应用程序，但它们只能存储在队列中。
初识RabbitMQ
QQ1817117243的博客
09-04 943
RabbitMQ是一个开源的消息代理软件，主要用于实现消息队列的功能。它允许应用程序之间通过消息进行异步通信，从而提高系统的可扩展性和可靠性。RabbitMQ支持多种消息协议，最常用的是AMQP（高级消息队列协议）。RabbitMQ广泛应用于微服务架构、分布式系统和实时数据处理等场景。
【RabbitMQ 项目】Muduo 库快速上手
weixin_74113106的博客
09-11 523
muduo库主要接口使用，结合样例中的应用层协议搭建服务器
在RabbitMQ中四种常见的消息路由模式
Xwz的博客
09-11 548
【代码】在RabbitMQ中四种常见的消息路由模式。
RabbitMQ的Direct Exchange模式实现的消息发布案例
最新发布
Xwz的博客
09-11 315
表示自动应答（auto-acknowledge），即消息处理完毕后，RabbitMQ会自动确认消息已成功处理。如果需要手动应答，可以将。：消费者的队列名称、交换机名称和路由键与生产者保持一致，即监听。获取消息内容，随后可以对消息进行处理、存储或其他业务逻辑操作。来定义收到消息后的处理逻辑。Consumer消费者代码。队列，并接收路由键为。，并在处理完成后调用。
RabbitMQ练习（AMQP 0-9-1 Overview）
zkyqss的博客
09-08 737
AMQP 0-9-1（高级消息队列协议）是一种网络协议，它允许遵从该协议的客户端（Publisher或者Consumer）应用程序与遵从该协议的消息中间件代理（Broker，如RabbitMQ）进行通信。
rabbitmq
qq_48501521的博客
09-11 614
消息服务概述：大多数应用中，可通过消息服务中间件来提升系统异步通信，扩展解耦能力两个重要概念：消息代理(message broker)和目的地(destination)。当消息发送者者发出消息后，将由消息代理接管，消息代理保证将消息传递至目的地两种形式的目的地：队列(queue):点对点的消息通信(point-to-point)主题(topic):发布(publish)/订阅(subscribe)的消息通信。
SpringBoot学习（8）RabbitMQ详解
L08130421的博客
09-06 1577
RabbitMQ 是实现 AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ 主要是为了实现系统之间的双向解耦而实现的。当生产者大量产生数据时，消费者无法快速消费，那么需要一个中间层。保存这个数据。AMQP，即 Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。
基于Linux和C++实现的RabbitMQ风格消息队列：设计与实现
卜及中的博客
09-11 523
源码该文件定义了 客户端服务器通信时所用到的请求和响应；由于参数需要进⾏⽹络传输以及序列化，所以需要将参数定义在pb⽂件中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值