RabbitMq

最新推荐文章于 2023-10-08 12:19:31 发布
最新推荐文章于 2023-10-08 12:19:31 发布
阅读量1.3k 收藏
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sy000223/article/details/121095402
版权

1、界面管理

2、代码实现点对点的消息发送与消费（也就是一个生产者对应一个消费者。）

/**
 * @author Suny
 * @data 2021/11/1 20:36
 * @description 生产者
 */
public class ProducerDemo01 {
    public static void main(String[] args) throws Exception {
        //创建mq的链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //配置rabbitmq的主机地址
        factory.setHost("127.0.0.1");
        //配置端口号
        factory.setPort(5672);
        //配置虚拟主机
        factory.setVirtualHost("/ems");
        //配置账户和密码
        factory.setUsername("ems");
        factory.setPassword("ems");
        //获取链接
        Connection connection = factory.newConnection();

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

        //参数 队列名、队列是否要持久化、队列是否只允许当前通道使用、队列在消费完之后是否自动删除、额外附加参数
        channel.queueDeclare("Hello",false,false,false,null);

        //发布消息
        //参数 交换机名称 、队列名称、传递消息的额外设置、消息具体内容
        channel.basicPublish("","Hello",null,"Hello,World".getBytes());

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



/**
 * @author Suny
 * @data 2021/11/1 20:50
 * @description 消费者
 */
public class ConsumerDemo01 {
    public static void main(String[] args) throws Exception {
        //创建mq的链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //配置rabbitmq的主机地址
        factory.setHost("127.0.0.1");
        //配置端口号
        factory.setPort(5672);
        //配置虚拟主机
        factory.setVirtualHost("/ems");
        //配置账户和密码
        factory.setUsername("ems");
        factory.setPassword("ems");
        //获取链接
        Connection connection = factory.newConnection();

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

        //通道绑定队列
        //参数 队列名、队列是否要持久化、队列是否只允许当前通道使用、队列在消费完之后是否自动删除、额外附加参数
        channel.queueDeclare("Hello",false,false,false,null);

        //消费消息
        //参数 队列名称、是否开启消息自动确认机制
        channel.basicConsume("Hello",true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String str = new String(body);
                System.out.println("str = " + str);
            }
        });

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

3、工作模式一个生产多个消费（一个生产者对应多个消费者，但是只能有一个消费者获得消息，也称之为竞争消费者模式。

）

/**
 * @author Suny
 * @data 2021/11/2 20:29
 * @description 工作模式
 */
public class WorkProducer {
    public static void main(String[] args) throws Exception{
        Connection connection = RabbitMqConfig.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("workQueue",true,false,false,null);
        for (int i = 0; i < 10; i++) {
            channel.basicPublish("","workQueue",MessageProperties.PERSISTENT_TEXT_PLAIN,(i +"Hello Work Queue").getBytes());
        }
        RabbitMqConfig.closeConnection(channel,connection);
    }
}

// 消费者
/**
 * @author Suny
 * @data 2021/11/2 20:34
 * @description 工作模式的消费者
 */
public class WorkConsumer {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMqConfig.getConnection();
        final Channel channel = connection.createChannel();
        //每次只消费、确认一条消息
        channel.basicQos(1);
        //参数 队列名、队列是否要持久化、队列是否只允许当前通道使用、队列在消费完之后是否自动删除、额外附加参数
        channel.queueDeclare("workQueue",true,false,false,null);
        //参数 队列名称、是否开启消息自动确认机制
        channel.basicConsume("workQueue",false,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));
                //当消息消费完之后开启手动确认机制
                //参数： 确认队列中那个具体的消息，是否开启多个消息同事确认
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }
}

4、发布订阅(一个消费者将消息首先发送到交换器，交换器绑定多个队列，然后被监听该队列的消费者所接收并消费。)

/**
 * @author Suny
 * @data 2021/11/8 21:04
 * @description 广播模式
 */
public class FanoutProducer {
    public static void main(String[] args) throws Exception{
        Connection connection = RabbitMqConfig.getConnection();
        Channel channel = connection.createChannel();
        //将通道声明指定的交换机
        //参数 交换机名称、交换机的模式fanout为广播
        channel.exchangeDeclare("logs","fanout");
        channel.basicPublish("logs","",null,"fanout".getBytes());
        channel.close();
        connection.close();
    }
}


/**
 * @author Suny
 * @data 2021/11/8 21:04
 * @description 广播消费者，每一个消费者都会消费消息
 */
public class FanoutConsumer {
    public static void main(String[] args) throws Exception{
        Connection connection = RabbitMqConfig.getConnection();
        Channel channel = connection.createChannel();
        //绑定交换机
        channel.exchangeDeclare("logs","fanout");
        //获取临时队列
        String queueName = channel.queueDeclare().getQueue();
        //队列绑定交换机
        //参数 队列名 交换机名 路由key
        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("Consumer1-fanout消费了");
            }
        });
    }
}

/**
 * @author Suny
 * @data 2021/11/8 21:04
 * @description 广播消费者
 */
public class FanoutConsumer2 {
    public static void main(String[] args) throws Exception{
        Connection connection = RabbitMqConfig.getConnection();
        Channel channel = connection.createChannel();
        //绑定交换机
        channel.exchangeDeclare("logs","fanout");
        //获取临时队列
        String queueName = channel.queueDeclare().getQueue();
        //队列绑定交换机
        //参数 队列名 交换机名 路由key
        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("Consumer2-fanout消费了");
            }
        });
    }
}

5、路由模式（生产者将消息发送到direct交换器，在绑定队列和交换器的时候有一个路由key，生产者发送的消息会指定一个路由key，那么消息只会发送到相应key相同的对列，接着监听该队列的消费者消费消息。）

/**
 * @author Suny
 * @data 2021/11/8 21:28
 * @description 路由模式
 */
public class DirectProducer {
    public static void main(String[] args) throws Exception{
        Connection connection = RabbitMqConfig.getConnection();
        Channel channel = connection.createChannel();
        //将通道声明指定的交换机
        //参数 交换机名称、交换机的模式DIRECT为广播
        channel.exchangeDeclare("logs_Direct", "direct");
        for (int i = 0; i < 10; i++) {
            if (i % 2 == 0){
                channel.basicPublish("logs_Direct","aaa",null,"DIRECT".getBytes());
            }else {
                channel.basicPublish("logs_Direct","bbb",null,"DIRECT".getBytes());
            }
        }
        channel.close();
        connection.close();
    }
}


/**
 * @author Suny
 * @data 2021/11/8 21:28
 * @description 路由模式
 */
public class DirectConsumer {
    public static void main(String[] args) throws Exception{
        Connection connection = RabbitMqConfig.getConnection();
        Channel channel = connection.createChannel();
        //绑定交换机 交换机名称、交换机模式DIRECT（路由）
        channel.exchangeDeclare("logs_Direct",BuiltinExchangeType.DIRECT);
        //获取临时队列
        String queueName = channel.queueDeclare().getQueue();
        //队列绑定交换机
        //参数 队列名 交换机名 路由key
        channel.queueBind(queueName,"logs_Direct","aaa");
        //消费消息
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String string = new String(body);
                System.out.println(string);
            }
        });
    }
}
/**
 * @author Suny
 * @data 2021/11/8 21:28
 * @description 路由模式
 */
public class DirectConsumer2 {
    public static void main(String[] args) throws Exception{
        Connection connection = RabbitMqConfig.getConnection();
        Channel channel = connection.createChannel();
        //绑定交换机 交换机名称、交换机模式DIRECT（路由）
        channel.exchangeDeclare("logs_Direct","direct");
        //获取临时队列
        String queueName = channel.queueDeclare().getQueue();
        //队列绑定交换机
        //参数 队列名 交换机名 路由key
        channel.queueBind(queueName,"logs_Direct","bbb");
        //消费消息
        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("Consumer1-fanout消费了");
            }
        });
    }
}

6、动态路由

/**
 * @author Suny
 * @data 2021/11/8 21:28
 * @description 动态路由模式、主题模式支持统配符号比如*
 */
public class TopicProducer {
    public static void main(String[] args) throws Exception{
        Connection connection = RabbitMqConfig.getConnection();
        Channel channel = connection.createChannel();
        //交换机名、交换机类型
        channel.exchangeDeclare("Topic", BuiltinExchangeType.TOPIC);
        String RoutingKey = "user.info";
        channel.basicPublish("Topic",RoutingKey,null,"Topic交换机".getBytes());
        RabbitMqConfig.closeConnection(channel,connection);
    }
}

/**
 * @author Suny
 * @data 2021/11/8 21:28
 * @description 动态路由
 */
public class TopicConsumer {
    public static void main(String[] args) throws Exception{
        Connection connection = RabbitMqConfig.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("Topic", BuiltinExchangeType.TOPIC);
        //获取临时队列
        String queueName = channel.queueDeclare().getQueue();
        //参数 队列名 交换机名 路由key
        //通配符*表示只匹配一个、#表示匹配多个
        channel.queueBind(queueName,"Topic","*.info");
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String str = new String(body);
                System.out.println(str);
            }
        });
    }
}

spring boot集成Rabbitmq

// 相关jar包
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        
        //相关配置文件
        # rabbitmq
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=ems
spring.rabbitmq.password=ems
spring.rabbitmq.virtual-host=/ems
# 手动ack
spring.rabbitmq.listener.simple.acknowledge-mode=manual
# 一次消费一条消息
spring.rabbitmq.listener.simple.prefetch= 1

spring boot生产者

package com.itheima.demo;

import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @author Suny
 * @data 2021/11/9 20:31
 * @description Springboot集成rabbitmq
 */
@SpringBootTest
public class RabbitmqTest {

    //注入rabbitmq的使用模板
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void  testHello(){
        //点对点模式
        //队列名和消息
        rabbitTemplate.convertAndSend("Boot","HelloRabbitmq");
    }

    @Test
    public void testWork(){
        //工作模式
        //队列名和消息
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend("work2","HelloWork");
        }
    }

    @Test
    public void testFanout(){
        //广播模式
        //交换机名、路由、消息
        rabbitTemplate.convertAndSend("FanoutExchange","","FanoutExchange");
    }

    @Test
    public void testRoutingKey(){
        //路由模式
        //交换机名、路由、消息
        rabbitTemplate.convertAndSend("RoutingKey2021","userInfo","RoutingKey2021");
    }

    @Test
    public void testTopic(){
        //动态路由模式
        //交换机名、路由、消息
        rabbitTemplate.convertAndSend("testTopic","user.Info","testTopic");
    }
}

spring boot消费者

/**
 * @author Suny
 * @data 2021/11/9 20:37
 * @description rabbitmq消费者
 * 点对点消费
 */
@Component
//当不配置持久化和自动删除时默认的是 不排他和非持久化的队列
@RabbitListener(queuesToDeclare = @Queue(value = "Boot",durable = "false",autoDelete = "false"))
public class Consumer {
    @RabbitHandler
    //@RabbitHandler使用此注解接收@RabbitListener指定的队列
    public void receive1(String message){
        System.out.println("message = " + message);
    }
}

/**
 * @author Suny
 * @data 2021/11/9 20:37
 * @description Springboot中使用work模式、并使用手动ACK进行消息确认
 */
@Component
public class WorkConsumer {

    @RabbitListener(queuesToDeclare = @Queue("work2"))
    public void receive1(String msg, Message message, Channel channel){
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            System.out.println("message1 = " + msg);
            channel.basicAck(deliveryTag,false);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    @RabbitListener(queuesToDeclare = @Queue("work2"))
    public void receive2(String msg, Message message, Channel channel){
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            System.out.println("message2 = " + msg);
            channel.basicAck(deliveryTag,false);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}


/**
 * @author Suny
 * @data 2021/11/9 20:56
 * @description 广播模式的消费
 */
@Component
public class FanoutConsumer {
    @RabbitListener(bindings = {
            @QueueBinding(
                    //如果不指定队列会创建临时队列
                    value = @Queue("fanout2021"),
                    exchange = @Exchange(value = "FanoutExchange",type = "fanout")
            )
    })
    public void receive1(String message){
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    //如果不指定队列会创建临时队列
                    value = @Queue("fanout2022"),
                    exchange = @Exchange(value = "FanoutExchange",type = "fanout")
            )
    })
    public void receive2(String message){
        System.out.println("message2 = " + message);
    }
}


/**
 * @author Suny
 * @data 2021/11/9 20:56
 * @description 路由模式
 */
@Component
public class RoutingConsumer {
    @RabbitListener(bindings = {
            @QueueBinding(
                    //如果不指定队列会创建临时队列
                    value = @Queue,
                    exchange = @Exchange(value = "RoutingKey2021",type = "direct"),
                    key = {"userInfo"}
            )
    })
    public void receive1(String message){
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    //如果不指定队列会创建临时队列
                    value = @Queue,
                    exchange = @Exchange(value = "RoutingKey2021",type = "direct"),
                    key = {"userInfo"}
            )
    })
    public void receive2(String message){
        System.out.println("message2 = " + message);
    }
}


/**
 * @author Suny
 * @data 2021/11/9 20:56
 * @description动态路由模式
 */
@Component
public class TopicConsumer {
    @RabbitListener(bindings = {
            @QueueBinding(
                    //如果不指定队列会创建临时队列
                    value = @Queue,
                    exchange = @Exchange(value = "testTopic",type = "topic"),
                    key = {"user.*"}
            )
    })
    public void receive1(String message){
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    //如果不指定队列会创建临时队列
                    value = @Queue,
                    exchange = @Exchange(value = "testTopic",type = "topic"),
                    key = {"user.*"}
            )
    })
    public void receive2(String message){
        System.out.println("message2 = " + message);
    }
}
Sy000223
关注
专栏目录
SpringBoot+rabbitMQ+TLS/SLL整合安装部署
大维子的博客
05-16 4121
SpringBoot+RabbitMQ+SSL/TLS整合与部署 ( 简单的安装和使用springboot整合MQ都是很简单,但是整合SSL的时候就很小白了,都是一点点查阅了解得到的部署流程.文章比较适合小白使用 ) 安装RabbitMQ(使用安装包或docker安装) 方案一：安装包安装MQ(Centos7X) 安装依赖文件 yum -y install gcc glibc-devel make ncurses-devel openssl-devel xmlto perl wget 安装erlang环境
RabbitMQ
05-01
**RabbitMQ详解** RabbitMQ是一款开源的消息队列系统，基于AMQP（Advanced Message Queuing Protocol）协议实现，广泛应用于分布式系统中的消息传递。它允许应用程序之间进行异步通信，提高了系统的可扩展性和容错...
RabbitMQ工厂&工具类
mengqingming1的博客
05-11 1380
rabbitMq工厂类，封装了创建连接，释放连接等操作 import java.io.IOException; import java.security.KeyManagementException; import java.security.NoSuchAlgorithmException; import java.util.concurrent.TimeoutException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; impor
SpringBoot RabbityMq 多数据源 配置SSL
qq_43010427的博客
01-21 1027
Maven <dependency> <groupId>org.springframework.amqp</groupId> <artifactId>spring-rabbit</artifactId> </dependency> <dependency> <groupId>org.spring
springboot+rabbitmq+openssl
Mr.Right的博客
05-14 3407
一.openssl相关知识简介 1.对称加密和非对称加密 对称加密很好理解，就是用密码加密一个文件，解密时需要用相同的密码来解析；而非对称加密则是用一个密码加密，但是用与加密密码不同的密码解密。 2.公钥、私钥和签名、验证签名。 私钥和公钥都可以进行加密和解密。公钥加密数据，私钥解密数据的过程称为加密解密，公钥加密的数据只有它相应的私钥才能解开，所以将公钥分给其他人，让其把数据加密，该数...
配置rabbitmq https SSL，springboot连接rabbitmq https
我怀念的
10-29 4376
springboot连接rabbitmq https
RabbitMQ Server3.13.0
最新发布
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
kettle rabbitmq 插件开发
10-26
标题 "kettle rabbitmq 插件开发" 涉及的是如何在 Pentaho Kettle（也称为 Spoon）中创建和使用 RabbitMQ 插件。Kettle 是一个开源的数据集成工具，它允许用户进行数据抽取、转换和加载（ETL）操作。RabbitMQ 是一个...
RabbitMQ实战指南-rabbitmq-action.zip
11-07
**RabbitMQ实战指南** RabbitMQ是一款广泛应用的开源消息队列系统，它基于Advanced Message Queuing Protocol（AMQP）标准，提供高可用性、可靠性和可扩展性。本实战指南将带你深入理解RabbitMQ的核心概念、安装与...
rabbitmq-c-master.rar_RabbitMQ c lib_cmake编译_rabbitmq_rabbitmq-c
09-23
`rabbitmq-c`是RabbitMQ的一个C语言客户端库，它使得在C程序中与RabbitMQ服务器进行交互变得更加简单。本文将详细介绍如何使用CMake编译`rabbitmq-c-master`源码，并讨论相关知识点。 首先，我们需要了解CMake，这...
SpringBoot+RabbitMQ
一名系统架构师的征途
08-08 3715
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。消息中间件在互联网公司的使用中越来越多，刚才还看到新闻阿里将RocketMQ捐献给了apache，当然了今天的主角还是讲RabbitMQ。消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不用关心是谁来消费，消费者不用关心谁在生产...
195、SpringBoot--配置RabbitMQ消息Broker的SSL 和 管理控制台的HTTPS
Java 领域技术分享
10-08 2025
SpringBoot--配置RabbitMQ消息Broker的SSL 和 管理控制台的HTTPS
springboot RabbitMQ TLS/SSL windows配置
chenyl
10-14 1558
一定要注意erlang和rabbitmq的版本配套,查看配套 下载rabbitmq早起版本要去github，网速不是很好，可以直接下载： windows地址:https://github.com/rabbitmq/rabbitmq-server/releases/download/vversion/rabbitmq−server−{version}/rabbitmq-server-version/rabbitmq−server−{version}.exe，如：https://github.com/ra.
springboot整合rabbitmq
admin522043032的博客
06-25 644
文章目录springboot整合rabbitmq springboot整合rabbitmq
RabbitMQ实战
InterceptWall的博客
08-28 2186
解耦：在项目启动之初来预测将来会碰到什么需求是极其困难的。消息中间件在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口，这允许你独立地扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束即可冗余〈存储) 有些情况下，处理数据的过程会失败。消息中间件可以把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失风险。在把 个消息从消息中间件中删除之前，需要你的处理系统明确地指出该消息己经被处理完成，从而确保你的数据被安全地保存直到你使用完毕。...
【亲测可用】禁用AMQP配置中的明文身份验证机制-漏洞解决方法（RabbitMQ开启SSL附SpringBoot连接测试代码）
拾级而上
01-07 1万+
被安全扫描出RabbitMQ 远程主机允许明文身份验证漏洞，本文教你解决它！
RabbitMQ生产者代码
Leon_Jinhai_Sun的博客
10-10 355
public class Producer { // 队列名称 public static final String QUEUE_NAME="hello"; // 发消息 public static void main(String[] args) throws IOException, TimeoutException { // 创建一个连接工厂 ConnectionFactory factory = new ConnectionFactory().
RabbitMQ 简单模式
weixin_51299408的博客
03-14 2787
RabbitMQ简单模式__读完队列所有消息__设置消息头__获取消息头
RabbitMQ的六种工作模式以及代码实现
热门推荐
sinJack的博客
08-20 3万+
一、什么是RabbitMQ rabbitmq是基于amqp协议实现一套高效的数据传输组件，MQ（消息队列）。 常见的MQ：ActiveMQ、Kafka、RocketMQ、RabbitMQ 官方文档：https://www.rabbitmq.com/getstarted.html 二、MQ的应用场景 1、消息异步通知(注册时邮箱认证、添加商品生成详情页和将商品添加到搜索库等) 2、消息顺序处理 3、消息延迟处理 4、请求削峰 三、六种工作模式 1.1 simple简单模式 1）消息产生后将消息放入队列 2）
RabbitMQ实战指南
"RabbitMQ Cookbook：由Sigismondo Boschi和Gabriele Santomaggio合著，该书提供了超过70个实用的食谱，旨在帮助读者利用RabbitMQ开发消息传递应用程序，通过大量现实生活中的例子进行教学。" 《RabbitMQ Cookbook...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值