【Storm】【综合案例】【二】Storm集群向Kafka集群读取数据并写入MySQL【远程模式】

已于 2023-03-12 11:12:04 修改
阅读量364 收藏 2
点赞数 1
分类专栏： Storm 文章标签： storm mysql kafka
于 2023-03-12 07:09:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41405524/article/details/129471702
版权

介绍

今天接上文，来实现一个Storm数据流处理综合案例的第二部分，Storm集群向Kafka集群源源不断读取数据，通过MyBatis写入到MySQL数据库，并部署为远程模式

准备工作

参考上文准备工作

代码编写

思路：Storm集群从Kafkatopic主题获取数据，解析后写入MySQL，注意我们使用MyBatis工具与数据库交互

项目结构

在这里插入图片描述

项目文件

POM

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zj</groupId>
    <artifactId>kafka-to-storm-integration</artifactId>
    <version>1.0</version>

    <properties>
        <storm.version>1.2.2</storm.version>
        <kafka.version>2.2.0</kafka.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.storm</groupId>
            <artifactId>storm-core</artifactId>
            <version>${storm.version}</version>
        </dependency>
        
        <dependency>
            <groupId>org.apache.storm</groupId>
            <artifactId>storm-kafka-client</artifactId>
            <version>${storm.version}</version>
        </dependency>
        
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>${kafka.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
            <!--使用shade进行打包-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <configuration>
                    <createDependencyReducedPom>true</createDependencyReducedPom>
                    <filters>
                        <filter>
                            <artifact>*:*</artifact>
                            <excludes>
                                <exclude>META-INF/*.SF</exclude>
                                <exclude>META-INF/*.sf</exclude>
                                <exclude>META-INF/*.DSA</exclude>
                                <exclude>META-INF/*.dsa</exclude>
                                <exclude>META-INF/*.RSA</exclude>
                                <exclude>META-INF/*.rsa</exclude>
                                <exclude>META-INF/*.EC</exclude>
                                <exclude>META-INF/*.ec</exclude>
                                <exclude>META-INF/MSFTSIG.SF</exclude>
                                <exclude>META-INF/MSFTSIG.RSA</exclude>
                            </excludes>
                        </filter>
                    </filters>
                    <artifactSet>
                        <excludes>
                            <exclude>org.apache.storm:storm-core</exclude>
                        </excludes>
                    </artifactSet>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

Topology

package read;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.StormSubmitter;
import org.apache.storm.generated.AlreadyAliveException;
import org.apache.storm.generated.AuthorizationException;
import org.apache.storm.generated.InvalidTopologyException;
import org.apache.storm.kafka.spout.KafkaSpout;
import org.apache.storm.kafka.spout.KafkaSpoutConfig;
import org.apache.storm.kafka.spout.KafkaSpoutRetryExponentialBackoff;
import org.apache.storm.kafka.spout.KafkaSpoutRetryExponentialBackoff.TimeInterval;
import org.apache.storm.kafka.spout.KafkaSpoutRetryService;
import org.apache.storm.topology.TopologyBuilder;

/**
 * 从Kafka中读取数据
 */
public class ReadingFromKafkaApp {

    private static final String BOOTSTRAP_SERVERS = "192.168.217.151:9092,192.168.217.152:9092";
    private static final String TOPIC_NAME = "kafkatopic";

    public static void main(String[] args) {

        final TopologyBuilder builder = new TopologyBuilder();
        builder.setSpout("kafka_spout", new KafkaSpout<>(getKafkaSpoutConfig(BOOTSTRAP_SERVERS, TOPIC_NAME)), 1).setNumTasks(1);
        builder.setBolt("split_bolt", new SplitBolt(), 1).shuffleGrouping("kafka_spout").setNumTasks(1);
        builder.setBolt("stat_store_bolt", new StatAndStoreBolt(), 2).shuffleGrouping("split_bolt").setNumTasks(2);

        Config config = new Config();
        config.setNumWorkers(4);
        config.setDebug(true);

        // 如果外部传参cluster则代表线上环境启动,否则代表本地启动
        if (args.length > 0 && args[0].equals("cluster")) {
            try {
                StormSubmitter.submitTopology("StormClusterReadingFromKafkaClusterApp", config, builder.createTopology());
            } catch (AlreadyAliveException | InvalidTopologyException | AuthorizationException e) {
                e.printStackTrace();
            }
        } else {
            LocalCluster cluster = new LocalCluster();
            cluster.submitTopology("LocalReadingFromKafkaApp",
                    config, builder.createTopology());
        }
    }

    private static KafkaSpoutConfig<String, String> getKafkaSpoutConfig(String bootstrapServers, String topic) {
        return KafkaSpoutConfig.builder(bootstrapServers, topic)
                // 除了分组ID,以下配置都是可选的。分组ID必须指定,否则会抛出InvalidGroupIdException异常
                .setProp(ConsumerConfig.GROUP_ID_CONFIG, "kafkaSpoutTestGroup")
                .setProp(ConsumerConfig.MAX_PARTITION_FETCH_BYTES_CONFIG, 200)
                // 定义重试策略
                .setRetry(getRetryService())
                // 定时提交偏移量的时间间隔,默认是15s
                .setOffsetCommitPeriodMs(10000)
                .setFirstPollOffsetStrategy(KafkaSpoutConfig.FirstPollOffsetStrategy.LATEST)
                .setMaxUncommittedOffsets(200)
                .build();
    }

    // 定义重试策略
    private static KafkaSpoutRetryService getRetryService() {
        return new KafkaSpoutRetryExponentialBackoff(TimeInterval.microSeconds(500),
                TimeInterval.milliSeconds(2), Integer.MAX_VALUE, TimeInterval.seconds(10));
    }
}

SplitBolt

package read;

import org.apache.storm.task.OutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseRichBolt;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.HashMap;
import java.util.Map;

/**
 * 切分从Kafka获取的数据
 */
public class SplitBolt extends BaseRichBolt {

    private OutputCollector collector;
    private String[] words;

    public void prepare(Map stormConf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
    }

    public void execute(Tuple tuple) {
        try {
            String line = tuple.getStringByField("value");
            System.out.println("received from kafka : " + line);
            words = line.split("\t");
            for(String word : words){
                collector.emit(new Values(word));
            }
            // 必须ack,否则会重复消费kafka中的消息
            collector.ack(tuple);
        } catch (Exception e) {
            e.printStackTrace();
            collector.fail(tuple);
        }
    }

    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("word"));
    }

}

StatAndStoreBolt

该Bolt通过MyBatis将处理好的数据写入到MySQL中，其中每10秒将数据写入一次数据库

package read;

import lombok.SneakyThrows;
import org.apache.storm.shade.org.apache.commons.collections.MapUtils;
import org.apache.storm.task.OutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseRichBolt;
import org.apache.storm.tuple.Tuple;
import read.dao.WordCountDao;
import read.entity.WordCount;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 打印从Kafka中获取的数据并实时写入到MySQL
 */
public class StatAndStoreBolt extends BaseRichBolt {

    Map<String, Integer> counters;
    private OutputCollector collector;

    // 记录最初时间
    private long begin = System.currentTimeMillis();

    @SneakyThrows
    public void prepare(Map stormConf, TopologyContext context, OutputCollector collector) {
        this.counters = new HashMap<String, Integer>();
        this.collector = collector;
    }

    @SneakyThrows
    public void execute(Tuple tuple) {
        long cost = System.currentTimeMillis();
        // 每10秒写一次数据库
        if (cost - begin > 10000 && MapUtils.isNotEmpty(counters)) {
            System.err.println(counters);
            updateWordCount(counters);
            // 重置最初时间
            begin = System.currentTimeMillis();
        }
        try {
            String word = tuple.getStringByField("word");
            //计数
            if(!counters.containsKey(word)){
                counters.put(word, 1);
            }else{
                Integer c = counters.get(word) + 1;
                counters.put(word, c);
            }
            // 必须ack,否则会重复消费kafka中的消息
            collector.ack(tuple);
        } catch (Exception e) {
            e.printStackTrace();
            collector.fail(tuple);
        }
    }

    public void declareOutputFields(OutputFieldsDeclarer declarer) {
    }

    public void updateWordCount(Map<String, Integer> counters) {
        List<WordCount> wordCounts = new ArrayList<>();
        for (Map.Entry<String, Integer> item : counters.entrySet()) {
            WordCount wc = new WordCount();
            wc.setWord(item.getKey());
            wc.setCount(item.getValue());
            wordCounts.add(wc);
        }
        WordCountDao.saveOrUpdateBatch(wordCounts);

    }

}

部署MySQL

我们在服务器上部署一台MySQL数据库

具体参考这篇文章

数据库表结构如下：

在这里插入图片描述

整合MyBatis

mybatis.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="mysql">
        <environment id="mysql">
            <!--配置事务管理器 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://192.168.217.171:3306/wordcount?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8&amp;
                          serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--指明映射文件的位置。-->
    <mappers>
        <mapper resource="mapper/WordCountMapper.xml"></mapper>
    </mappers>

</configuration>

SqlSessionConfig

该配置类会读取mybatis.xml文件获取相应的配置信息，生成SqlSessionFactory工厂

package read.config;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.Reader;

public class SqlSessionConfig {
    public static SqlSessionFactory GetConn() {
        Reader reader = null;
        try {
            reader = Resources.getResourceAsReader("mybatis.xml");
            return new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

WordCountMapper

该接口定义了MyBatis访问数据库的接口方法

package read.mapper;

import org.apache.ibatis.annotations.Param;
import read.entity.WordCount;

import java.util.List;

public interface WordCountMapper {

    List<WordCount> selectAll();

    void saveOrUpdateBatch(@Param("wordCountList") List<WordCount> wordCountList);

}

WordCountDao

该类会获取SqlSessionConfig配置类的SqlSessionFactory和WordCountMapper的接口方法，生成具体与数据库交互的Session

package read.dao;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import read.config.SqlSessionConfig;
import read.entity.WordCount;
import read.mapper.WordCountMapper;

import java.util.List;

public class WordCountDao {

    /**
     * 获取所有查询信息
     * @return
     */
    public static List<WordCount> selectAll(){
        SqlSessionFactory factory = SqlSessionConfig.GetConn();
        SqlSession session = factory.openSession();
        WordCountMapper db = session.getMapper(WordCountMapper.class);
        List<WordCount> list = db.selectAll();
        session.commit();
        session.close();
        return list;
    }

    /**
     * 批量更新或插入
     * @param wordCountList
     */
    public static void saveOrUpdateBatch(List<WordCount> wordCountList) {
        SqlSessionFactory factory = SqlSessionConfig.GetConn();
        SqlSession session = factory.openSession();
        WordCountMapper db = session.getMapper(WordCountMapper.class);
        db.saveOrUpdateBatch(wordCountList);
        session.commit();
        session.close();
    }

}

WordCountMapper.xml

该文件为MyBatis编写与数据库交互的具体SQL代码的地方

具体实现了全量查询和批量更新或插入的接口功能

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace：命名空间。目前取值没有要求，建议取当前文件的完整路径名，省略xml-->
<mapper namespace="read.mapper.WordCountMapper">

    <select id="selectAll" resultType="read.entity.WordCount">
        select * from wordcounts
    </select>

    <insert id="saveOrUpdateBatch" parameterType="list">
        insert into wordcounts (`word`, `count`) values
        <foreach collection="wordCountList" item="item" index="index" separator=",">
            (#{item.word},#{item.count})
        </foreach>
        ON DUPLICATE KEY UPDATE
        `word` = values(`word`),
        `count` = values(`count`)
    </insert>

</mapper>

远程部署

打包

使用shade打包

在这里插入图片描述

上传文件

文件只需上传到Nimbus节点即可

使用Nimbus节点启动Topology

storm jar kafka-to-storm-integration-1.0.jar  read.ReadingFromKafkaApp cluster

在这里插入图片描述

UI查看

在这里插入图片描述

验证测试

思路：查看服务器上的MySQL是否收到了数据

在这里插入图片描述

附：日志查看

Nimbus节点

cd /usr/local/storm/logs

tail -100f nimbus.log

在这里插入图片描述

Supervisor节点

cd /usr/local/storm/logs

tail -100f supervisor.log

在这里插入图片描述

UI

cd /usr/local/storm/logs

tail -100f ui.log

在这里插入图片描述

BirdMan98
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
实时数据处理：Kafka与Storm实战
禅与计算机程序设计艺术
01-28 695
1.背景介绍 在今天的数据驱动经济中，实时数据处理技术已经成为企业竞争力的重要组成部分。Apache Kafka和Apache Storm是两个非常受欢迎的开源项目，它们分别用于构建大规模、高吞吐量的分布式系统。本文将深入探讨Kafka和Storm的核心概念、算法原理、最佳实践以及实际应用场景，并为读者提供一些有价值的技术洞察和建议。 1. 背景介绍 1.1 Kafka的发展历程 Apac...
Storm集成kafka
weixin_44911248的博客
07-18 295
Storm集成kafka
大数据-Storm流式框架（六)---Kafka介绍
最新发布
yaya_jn的博客
10-27 1168
默认的消息保留策略是，要么保存一段时间（7天），要么保留消息到一定大小的字节数（1GB）。1、kafka的生产者在发送消息到kafka的时候，如果消息没有指定key，则按照轮询的策略，依次将各个消息发送给不同的主题的分区。最简单的例子，为键生成一个一致性散列值，然后使用散列值对主题分区进行取模，为消息选择分区。分区器为消息的键生成一个散列值，映射到指定的分区上。，紧凑的序列化格式，模式和消息体分开，支持强类型和模式进化，版本前后兼容。broker接收来自生产者的消息，为消息设置偏移量，提交消息到磁盘保存。
storm与kafka结合
王帆的专栏
01-21 3754
一、kafka基本概念       1、kafka是一个分布式的消息缓存系统       2、kafka集群中的服务器都叫做broker       3、kafka有两类客户端，一类叫producer（消息生产者），一类叫做consumer（消息消费者），客户端和broker服务器之间采用tcp协议连接       4、kafka中不同业务系统的消息可以通过topic进行区分，而且每一个消
大数据学习路径
寻寻觅觅的专栏
05-19 8098
1.Linux基础和分布式集群技术 学完此阶段可掌握的核心能力： 熟练使用Linux，熟练安装Linux上的软件，了解熟悉负载均衡、高可靠等集群相关概念，搭建互联网高并发、高可靠的服务架构； 学完此阶段可解决的现实问题： 搭建负载均衡、高可靠的服务器集群，可以增大网站的并发访问量，保证服务不间断地对外服务； 学完此阶段可拥有的市场价值： 具备初级程序员必要具备的Li
storm 安装 mysql_storm-安装
weixin_39529903的博客
01-19 121
1. 单机安装storm测试环境2. 集群storm安装http://blog.csdn.net/tanggao1314/article/details/523486322. storm 将处理结果保存到mysql2) 将jar包上传到storm lib目录3) 将jar 导入到idea4) 按照java 操作mysql 即可需求，将storm的一个数据流，直接保存到es，可以省略很多环节!测试1...
Storm综合案例二Storm集群向Kafka集群读取数据并写入MySQL远程模式
03-12
今天接上文，来实现一个Storm数据流处理综合案例的第二部分，Storm集群向Kafka集群源源不断读取数据，通过MyBatis写入到MySQL数据库，并部署为远程模式 准备工作 参考上文准备工作 代码编写 思路：Storm集群从...
Storm综合案例一Storm集群向Kafka集群写入数据远程模式
03-12
今天来实现一个Storm数据流处理综合案例的第一部分，Storm集群向Kafka集群源源不断写入数据，并部署为远程模式 准备工作 搭建三台Kafka集群服务器 参考文档：Linux部署Kafka集群 搭建三台Storm集群服务器 参考...
StormStorm集成Kafka 从Kafka中读取数据
03-12
Storm集成Kafka 一、整合说明 二、写入数据到Kafka 三、从Kafka中读取数据 从Kafka中读取数据 Storm从Kafka集群读取数据处理
kafka与storm集群环境的安装步骤详解
08-28
主要给大家介绍了关于kafka与storm集群环境安装步骤的相关资料，两者并不是一定联系的，写在一起主要是因为两个都是有zookeeper管理的，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面随着小编来...
KafkaTopology
07-02
Kafka拓扑 此拓扑写入和读取 kafka 集群。 KafkaProducer 是写入 kafka 集群的 spout，而 KafkaConsumer 是从 kafka 集群消费的 bolt。
Flink实时读取Kafka数据批量聚合（定时按数量）写入Mysql.rar
12-27
Flink实时读取Kafka数据批量聚合（定时/按数量）写入Mysql源码+kafka安装包+zookeeper安装包
storm mysql字段更新_Storm常见问题及解决方案总结
weixin_42511177的博客
02-11 122
1、storm集群配置JDK环境变量问题问题分析：在linux系统下配置JDK后一般修改/etc/profile值进行环境变量配置，但是安装storm集群时会出现问题问题解决：需要在/etc/.bashrc文件中也加入环境变量不然安装的JDK无法使用。2、supervisor相关问题1)安装后supervisor名称相同并且启动报错问题问题分析：supervisor.cji中有行代码如下：1此代码...
storm mysql 结合_storm 与mysql整合问题
weixin_39543835的博客
02-11 162
首先说明下问题的情况，1、我storm 环境已经搭建完成，在本地测试wordcount是没问题的，2、我在wordcount中加入一个MysqlBolt，此Bolt只是简单的把 wordcount的结果存入mysql数据库中，在本地模式测试测试时，完全可以把结果插入指定表。3、我的每个storm 节点都已经把mysql-connector-java-5.1.23.jar 放到storm的lib目录...
Storm与Kafka的集成
蔡政洁的博客
01-04 635
目录一、深入Kafka服务架构原理二、kafka集群安装与部署三、基于maven构建Storm-kafka工程四、Storm-kafka编程模型 版本选择： storm-1.2.3 kafka_2.11-0.8.2.2 一、深入Kafka服务架构原理 行业里最流行的Message Queue产品； MQ的特点：生产者，消费者 Kafka是LinkedIn开源出来的一个高吞吐的分布式消息系统。 使用scala开发，支持多语言客户端（c++、java、python等） 其具有以下特点： 支持高Throu
Storm 消费Kafka数据及相关异常解决
zx711166的博客
03-30 2310
Storm 消费Kafka数据及相关异常解决问题KafkaTopoDemo类bolt类 问题 storm报错：Exception in thread “main” java.lang.RuntimeException: InvalidTopologyException(msg:Component: [mybolt] subscribes from non-existent stream: [default] of component [kafka_spout]) storm版本：2.3.0 kafka版本：
Storm-kafka集成——1.1.0版本storm中tuple取KafkaSpout数据详解
上好佳的博客
04-02 5370
问题描述：KafkaSpout拉取kafka topic数据，下一级bolt从kafkaspout获取数据，tuple到底采用什么方法取出spout中的消息呢？KafkaSpout创建：/* *根据数据源topic和zk_id创建并返回kafkaSpout * */ public static KafkaSpout init(String spout_topic,String zk_id){ ...
storm-kafka源码分析
jediael_lu的专栏
08-13 3726
storm-kafka源码分析@(KAFKA)[kafka, 大数据, storm]storm-kafka源码分析 一概述 一代码结构 二orgapachestormkafka 三orgapachestormkafkatrident 1spout 2state 3metric 四其它说明 1线程与分区 二orgapachestormkafka 一基础类 1Broker 2BrokerHosts 3P
flink消费kafka数据并批量写入mysql
08-09
总结起来，要使用Flink消费Kafka数据并批量写入MySQL，首先需要创建一个Flink应用程序来消费Kafka数据，并使用Flink的JDBC连接器来批量写入MySQL。同时，还需要使用Flink的定时器和状态管理来控制批量写入的频率和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

BirdMan98

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

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

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

打赏作者

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

抵扣说明：

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

余额充值