RabbitMQ

已于 2023-05-27 16:14:34 修改
阅读量137 收藏 1
点赞数 1
分类专栏： RabbitMQ 文章标签： java-rabbitmq rabbitmq java
于 2023-05-27 15:48:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangshiqi666/article/details/130893078
版权

pom依赖(生产者消费者相同)：

    <dependencies>
        <!--rabbitmq java客户端-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.6.0</version>
        </dependency>
    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

1.HelloWorld

生产者：

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 Producer_HelloWord {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 2.设置参数
        factory.setHost("8.140.49.229"); // 默认localhost
        factory.setPort(5672); // 默认5672
        factory.setVirtualHost("/"); // 默认/
        factory.setUsername("guest"); // 默认guest
        factory.setPassword("guest"); // 默认guest
        // 3.创建连接Connection
        Connection connection = factory.newConnection();
        // 4.创建Channel
        Channel channel = connection.createChannel();
        // 5.创建队列Queue
        /*
         * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
         * 1.队列名
         * 2.是否持久化，当mq重启之后，是否在
         * 3.# 是否独占。只能一个消费者监听队列
         *   # 当Connection关闭时，是否删除队列
         * 4.当没有Consumer时，是否删除队列
         * 5.参数
         */
        channel.queueDeclare("hello_world", true, false, false, null); // 若队列名称冲突则不创建

        // 6.发送消息
        /*
         * basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
         * 1.Exchange名，简单模式交换机使用默认""
         * 2.路由名称 (如果是默认Exchange""，必须和队列名相同)
         * 3.配置信息
         * 4.发送消息数据
         */
        String body = "hello rabbitmq~~~";
        channel.basicPublish("", "hello_world", null, body.getBytes());

        // 7.释放资源
        channel.close();
        connection.close();
    }
}

消费者：

import com.rabbitmq.client.*;

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

/**
 * 接收消息
 */
public class Consumer_HelloWorld {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 2.设置参数
        factory.setHost("8.140.49.229"); // 默认localhost
        factory.setPort(5672); // 默认5672
        factory.setVirtualHost("/"); // 默认/
        factory.setUsername("guest"); // 默认guest
        factory.setPassword("guest"); // 默认guest
        // 3.创建连接Connection
        Connection connection = factory.newConnection();

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

        // 5.接受消息
        /*
         * basicConsume(String queue, boolean autoAck, Consumer callback)
         * 1.队列名
         * 2.是否自动确认
         * 3.回调对象
         */
        Consumer consumer = new DefaultConsumer(channel) {
            // 回调方法，当收到消息后自动执行该方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                System.out.println("consumerTag = " + consumerTag); // 标识
                System.out.println("Exchange = " + envelope.getExchange()); // 信息，交换机，路由key
                System.out.println("RoutingKey = " + envelope.getRoutingKey());
                System.out.println("properties = " + properties); // 配置信息
                System.out.println("body: " + new String(body)); // body数据
                System.out.println("===============================");
            }
        };
        channel.basicConsume("hello_world", true, consumer);

        // 消费者不用释放资源
    }
}

2.RabbitMQ工作模式

2.1 Work queues 工作队列模式

工具类：

package com.wsq.utils;

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 MyConnections {
    public Connection connection = null;
    public Channel channel = null;

    public Channel getChannel() throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 2.设置参数
        factory.setHost("8.140.49.229"); // 默认localhost
        factory.setPort(5672); // 默认5672
        factory.setVirtualHost("/"); // 默认/
        factory.setUsername("guest"); // 默认guest
        factory.setPassword("guest"); // 默认guest
        // 3.创建连接Connection
        connection = factory.newConnection();
        // 4.创建Channel
        channel = connection.createChannel();
        return channel;
    }

    public void closed() throws IOException, TimeoutException {
        channel.close();
        connection.close();
    }

}

生产者：

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.wsq.utils.MyConnections;

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

/**
 * 工作队列：发送消息(接收的时候是轮询接收)
 */
public class Producer_b_WorkQueues {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        // 4.创建Channel
        Channel channel = myConnections.getChannel();
        // 5.创建队列Queue
        channel.queueDeclare("work_queues", true, false, false, null); // 如何队列名称冲突则不会创建

        // 6.发送消息
        /*
         * basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
         * 1.交换机名称，简单模式下交换机用默认的“”
         * 2.路由名称 (如果是默认交换机，则必须和队列名称一样)
         * 3.配置信息
         * 4.发送的消息数据
         */
        for (int i = 0; i < 10; i++) {
            String body = i + "hello rabbitmq~~~";
            channel.basicPublish("", "work_queues", null, body.getBytes());
        }
        // 7.释放资源
        myConnections.closed();
    }
}

消费者1：

import com.rabbitmq.client.*;
import com.wsq.utils.MyConnections;

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

/**
 * 接收消息
 */
public class Consumer_b_WorkQueues1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        Channel channel = myConnections.getChannel();

        // 5.接受消息
        Consumer consumer = new DefaultConsumer(channel) {
            // 回调方法，当收到消息后会自动执行该方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                System.out.println("body: " + new String(body));
            }
        };
        channel.basicConsume("work_queues", true, consumer);
    }
}

消费者2：

import com.rabbitmq.client.*;
import com.wsq.utils.MyConnections;

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

/**
 * 接收消息
 */
public class Consumer_b_WorkQueues2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        Channel channel = myConnections.getChannel();

        // 6.接受消息
        Consumer consumer = new DefaultConsumer(channel) {
            // 回调方法，当收到消息后会自动执行该方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                System.out.println("body: " + new String(body));
            }
        };
        channel.basicConsume("work_queues", true, consumer);
    }
}

2.2 Pub/Sub 订阅模式

 生产者：

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.wsq.utils.MyConnections;

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

/**
 * FANOUT交换机类型：发送给所以消费者：发送消息
 */
public class Producer_c_PubSub {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        // 4.创建Channel
        Channel channel = myConnections.getChannel();
        // 5.创建交换机Exchange
        /*
         * exchangeDeclare(String exchange, 交换机名称
         *         BuiltinExchangeType type, 交换机类型 (DIRECT("direct")定向, FANOUT("fanout")广播, TOPIC("topic")通配符方式)
         *         boolean durable, 是否持久化
         *         boolean autoDelete, 是否自动删除
         *         boolean internal, 内部使用，一般false
         *         Map<String, Object> arguments) 参数
         */
        String exchangeName = "test_fanout";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT, true, false, false, null); // ⭐
        // 6.创建队列Queue
        String queue1Name = "test_fanout_queue1";
        String queue2Name = "test_fanout_queue2";
        channel.queueDeclare(queue1Name, true, false, false, null);
        channel.queueDeclare(queue2Name, true, false, false, null);
        // 7.绑定Exchange、Queue
        /*
         * queueBind(String queue, String exchange, String routingKey)
         * 1.队列名
         * 2.交换机名
         * 3.路由键，绑定规则
         *  若交换机类型为fanout，routingKey为""
         */
        channel.queueBind(queue1Name, exchangeName, "");
        channel.queueBind(queue2Name, exchangeName, "");
        // 8.发送消息
        String body = "日志信息：张三调用了findAll方法...日志级别：info...";
        channel.basicPublish(exchangeName, "", null, body.getBytes());
        // 9.释放资源
        myConnections.closed();
    }
    
}

消费者：

import com.rabbitmq.client.*;
import com.wsq.utils.MyConnections;

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

/**
 * 消费者1
 */
public class Consumer_c_PubSub1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        Channel channel = myConnections.getChannel();

        String queue1Name = "test_fanout_queue1";

        // 5.接受消息
        /*
         * basicConsume(String queue, boolean autoAck, Consumer callback)
         * 1.队列名称
         * 2.是否自动确认
         * 3.回调对象
         */
        Consumer consumer = new DefaultConsumer(channel) {
            // 回调方法，当收到消息后会自动执行该方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                System.out.println("body: " + new String(body));
                System.out.println("将日志信息打印到控制台");
            }
        };
        channel.basicConsume(queue1Name, true, consumer);
    }

}
import com.rabbitmq.client.*;
import com.wsq.utils.MyConnections;

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

/**
 * 消费者2
 */
public class Consumer_c_PubSub2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        Channel channel = myConnections.getChannel();

        String queue2Name = "test_fanout_queue2";

        // 5.接受消息
        /*
         * basicConsume(String queue, boolean autoAck, Consumer callback)
         * 1.队列名称
         * 2.是否自动确认
         * 3.回调对象
         */
        Consumer consumer = new DefaultConsumer(channel) {
            // 回调方法，当收到消息后会自动执行该方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                System.out.println("body: " + new String(body));
                System.out.println("将日志信息保存数据库");
            }
        };
        channel.basicConsume(queue2Name, true, consumer);
    }

}

2.3 Routing 路由模式

生产者：

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.wsq.utils.MyConnections;

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

/**
 * DIRECT交换机类型：只发送给绑定相同的routingkey的消费者：发送消息
 */
public class Producer_d_Routing {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        Channel channel = myConnections.getChannel();
        // 5.创建交换机
        /*
         * exchangeDeclare(String exchange, 交换机名称
         *         BuiltinExchangeType type, 交换机类型 (DIRECT("direct")定向, FANOUT("fanout")广播, TOPIC("topic")通配符方式)
         *         boolean durable, 是否持久化
         *         boolean autoDelete, 是否自动删除
         *         boolean internal, 内部使用，一般false
         *         Map<String, Object> arguments) 参数
         */
        String exchangeName = "test_direct";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT, true, false, false, null); // ⭐
        // 6.创建队列
        String queue1Name = "test_direct_queue1";
        String queue2Name = "test_direct_queue2";
        channel.queueDeclare(queue1Name, true, false, false, null);
        channel.queueDeclare(queue2Name, true, false, false, null);
        // 7.绑定队列和交换机
        // 队列1绑定error
        channel.queueBind(queue1Name, exchangeName, "error");
        // 队列2绑定info error warning
        channel.queueBind(queue2Name, exchangeName, "info");
        channel.queueBind(queue2Name, exchangeName, "error");
        channel.queueBind(queue2Name, exchangeName, "warning");
        // 8.发送消息
        String body = "日志信息：张三调用了findAll方法...日志级别：info...";
//        String body = "日志信息：张三调用了delete方法...日志级别：error...";
        channel.basicPublish(exchangeName, "info", null, body.getBytes());
//        channel.basicPublish(exchangeName, "error", null, body.getBytes());
        // 9.释放资源
        myConnections.closed();
    }
    
}

消费者：

import com.rabbitmq.client.*;
import com.wsq.utils.MyConnections;

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

/**
 * 接收消息
 */
public class Consumer_d_Routing1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        Channel channel = myConnections.getChannel();

        String queue1Name = "test_direct_queue1";

        // 6.接受消息
        Consumer consumer = new DefaultConsumer(channel) {
            // 回调方法，当收到消息后会自动执行该方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                System.out.println("body: " + new String(body));
                System.out.println("将日志信息保存数据库");
            }
        };
        channel.basicConsume(queue1Name, true, consumer);
    }
    
}

import com.rabbitmq.client.*;
import com.wsq.utils.MyConnections;

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

/**
 * 接收消息
 */
public class Consumer_d_Routing2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        Channel channel = myConnections.getChannel();

        String queue2Name = "test_direct_queue2";

        // 6.接受消息
        Consumer consumer = new DefaultConsumer(channel) {
            // 回调方法，当收到消息后会自动执行该方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                System.out.println("body: " + new String(body));
                System.out.println("将日志信息打印到控制台");
            }
        };
        channel.basicConsume(queue2Name, true, consumer);
    }

}

2.4 Topics 通配符模式

 

生产者：

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.wsq.utils.MyConnections;

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

/**
 * TOPIC交换机：通配符绑定消费者：发送消息
 */
public class Producer_e_Topic {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        Channel channel = myConnections.getChannel();
        // 5.创建交换机
        /*
         * exchangeDeclare(String exchange, 交换机名称
         *         BuiltinExchangeType type, 交换机类型 (DIRECT("direct")定向, FANOUT("fanout")广播, TOPIC("topic")通配符方式)
         *         boolean durable, 是否持久化
         *         boolean autoDelete, 是否自动删除
         *         boolean internal, 内部使用，一般false
         *         Map<String, Object> arguments) 参数
         */
        String exchangeName = "test_topic";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC, true, false, false, null); // ⭐
        // 6.创建队列
        String queue1Name = "test_topic_queue1";
        String queue2Name = "test_topic_queue2";
        channel.queueDeclare(queue1Name, true, false, false, null);
        channel.queueDeclare(queue2Name, true, false, false, null);
        // 7.绑定队列和交换机
        // routing key 系统的名称。日志的级别
        // 需求：所有error级别的日志存入数据库，所以order系统的日志存入数据库
        channel.queueBind(queue1Name, exchangeName, "#.error"); // #代表多个单词
        channel.queueBind(queue1Name, exchangeName, "order.*"); // *代表一个单词
        channel.queueBind(queue2Name, exchangeName, "*.*");
        // 8.发送消息
        String body = "日志信息：张三调用了findAll方法...日志级别：info...";
//        channel.basicPublish(exchangeName, "order.info", null, body.getBytes());
//        channel.basicPublish(exchangeName, "goods.info", null, body.getBytes());
        channel.basicPublish(exchangeName, "goods.error", null, body.getBytes());
        // 9.释放资源
        myConnections.closed();
    }
    
}

消费者：

import com.rabbitmq.client.*;
import com.wsq.utils.MyConnections;

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

/**
 * 接收消息
 */
public class Consumer_e_Topic1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        Channel channel = myConnections.getChannel();

        String queue1Name = "test_topic_queue1";

        // 6.接受消息
        Consumer consumer = new DefaultConsumer(channel) {
            // 回调方法，当收到消息后会自动执行该方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                System.out.println("body: " + new String(body));
                System.out.println("将日志信息保存数据库");
            }
        };
        channel.basicConsume(queue1Name, true, consumer);
    }
    
}

import com.rabbitmq.client.*;
import com.wsq.utils.MyConnections;

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

/**
 * 接收消息
 */
public class Consumer_e_Topic2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        MyConnections myConnections = new MyConnections();
        Channel channel = myConnections.getChannel();

        String queue2Name = "test_topic_queue2";

        // 6.接受消息
        Consumer consumer = new DefaultConsumer(channel) {
            // 回调方法，当收到消息后会自动执行该方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                System.out.println("body: " + new String(body));
                System.out.println("将日志信息打印到控制台");
            }
        };
        channel.basicConsume(queue2Name, true, consumer);
    }
    
}

3.工作模式总结

王雀跃
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
rabbitmqadmin
07-08
RabbitMQ命令行手动创建队列rabbitmqadmin用法 手动创建队列方法：登录http://ip:15672/cli下载 将下载的rabbitmqadmin放到/usr/sbin目录下，并赋予权限：chmod 755 rabbitmqadmin 查看命令帮助信息： python ...
RabbitMQ安装
qq_57442639的博客
07-02 9331
rabbitmq
Rabbitmq
asddasddeedd的博客
11-19 6029
消息队列 消息服务器 消息中间件 Borker。
RabbitMQ入门
SICAUliuy的博客
04-20 2570
RabbitMQ简介 安装步骤 在centos7环境上， 因为是最小化安装，需要先yum install gcc 依赖 wget 对应的安装包 erlang、socat、rabbitmq-server 通过rpm 安装 顺序是 erlang、socat、rabbitmq-server 常用命令 # 启动 systemctl start rabbitmq-server # 添加web管理插件 rabbitmq-plugins enable rabbitmq_management # 重启 syst
RabbitMQ 集群
dingd1234的博客
06-12 9932
1.2 集群搭建 使容器 mq02 称为从节点，容器 mq01 为主节点 使容器 mq03 称为从节点，容器 mq01 为主节点 1.3 查看集群状态 进入任意一个容器内，输入以下命令查看集群状态：
linux安装rabbitmq
zjg
12-31 2980
rabbit是使用erlang语言开发的，所以我们需要先进行erlang的安装，版本也要对的上，本次以安装为最新版的安装包形式进行安装。回到顶部。
RabbitMQ Server3.13.0
最新发布
04-02
RabbitMQ Server端exe安装包下载 附带erlang 语言包 otp_win64_26.2.2
RabbitMq
01-20
Java操作RabbitMq simple 简单队列 work queues 工作队列 公平分发 轮询分发 public/subscribe 发布订阅 routing 路由选择 通配符模式 topics 主题 手动和自动确认消息 队列的持久化和非持久化 RabbitMq的延迟队列 ...
rabbitmq开发规范
07-04
1：rabbitmq的命名规范 2：rabbitmq生产者开发规范 3：rabbitmq消费者开发规范
rabbitmq3.10.4
06-07
rabbitmq3.10.4
rabbitmq安装包
09-22
erlang、rabbitmq、socat
rabbitmq.config
09-24
3.8.8中没有rabbitmq.conf...3.7.x版本中默认安装完成后配置文件模板在:/usr/share/doc/rabbitmq-server-3.7.18/rabbitmq.config.example目录中,需要将配置文件复制到/etc/rabbitmq/目录中,并修改名称为rabbitmq.config
rabbitmq安装
02-21
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。
rabbitmq 3.10.2 window安装包
07-05
otp_win64_25.0.2 rabbitmq 3.10.2 安装步骤：https://blog.csdn.net/qq_36802726/article/details/125619207
rabbitmq 3.9.3 配置文件
10-07
rabbitmq 3.9.3 配置文件
rabbitmq3.7.11
12-22
linux下安装的rabbitmq，版本为rabbitmq-server-3.7.11-1.el7.noarch.rpm
rabbitmq to rabbitmq
03-27
RabbitMQ是一个开源的消息中间件，它实现了高级消息队列协议（AMQP）并提供可靠的消息传递机制。它允许应用程序之间进行异步通信，并支持多种消息模式，如点对点、发布/订阅和工作队列。 当我们提到"RabbitMQ to ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王雀跃

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值