使用Spark读写外部存储介质（Mysql、Hbase、Redis）

最新推荐文章于 2021-03-31 11:15:57 发布
最新推荐文章于 2021-03-31 11:15:57 发布
阅读量261 收藏
点赞数 1
文章标签： mysql jdbc spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lei729533667/article/details/114831986
版权

使用Spark读写外部存储介质（Mysql、Hbase、Redis）

1、使用Spark与Mysql交互

1.1 需要加载的依赖

druid提供数据库连接池创建、维护和监控的功能。

		<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
         <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.9</version>
        </dependency>

1.2 需要设置的配置项

需要指定url，url由连接串、端口号、SSL认证组成。

driverClassName=org.gjt.mm.mysql.Driver
url=连接串:端口号/库名?useSSL=true
username=账号
password=密码
initialSize=2
maxActive=10
maxWait=10000

validationQuery=SELECT 1
testWhileIdle=true
testOnBorrow=false
testOnReturn=false

1.3 代码

连接池ds在一个实例中只需要初始化一次，便可多次复用从中getConnection。

import java.sql.{Connection, ResultSet, Statement}
import java.text.SimpleDateFormat
import java.util.{Date, Properties}

import com.alibaba.druid.pool.{DruidDataSource, DruidDataSourceFactory}

object demoMysql {
  def main(args: Array[String]): Unit = {
    /** 读取mysql连接配置 **/
    val properties = new Properties()
    val propertiesPath = getClass.getClassLoader.getResourceAsStream("druid_config_test.properties")
    properties.load(propertiesPath)


    /** 创建连接 **/
    val ds = DruidDataSourceFactory.createDataSource(properties) //基于配置创建连接池
    val conn: Connection = ds.getConnection() //获取连接对象

    val now = new Date().getTime //时间戳
    val dateFormatDay: SimpleDateFormat = new SimpleDateFormat("yyyyMMdd")
    val dayBefore = dateFormatDay.format(now)
    val incDay = "20200418"


    val sql = s"select * from dceport.ll_khsc_dept_dist_city_map  partition (p$incDay) where dept_code = 'TC771Y' order by inc_day desc limit 1"
    println(sql)
    val stmt: Statement = conn.createStatement
    val rs: ResultSet = stmt.executeQuery(sql)
    while (rs.next()) {
      val res = rs.getString("dept_code")
      println(res)
    }

  }
}

2、使用Spark与Hbase交互

2.1 需要加载的依赖

    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-client</artifactId>
        <version>1.3.1</version>
    </dependency>

2.2 代码

quorum一般由运维提供，测试环境zk域名需要在本地hosts文件中添加。

import org.apache.hadoop.hbase.{HBaseConfiguration, TableName}
import org.apache.hadoop.hbase.client.{ConnectionFactory, Delete, Get, HTable, Put}
import org.apache.hadoop.hbase.util.Bytes


object demoHbase {
  def main(args: Array[String]): Unit = {
    val quorum = "CNSZ22PL0138,CNSZ22PL0139,CNSZ22PL0140,CNSZ22PL0141,CNSZ22PL0142"
    val hbaseConf = HBaseConfiguration.create()
    hbaseConf.set("hbase.zookeeper.quorum", quorum)
    hbaseConf.set("hbase.zookeeper.property.clientPort", "2181")
    hbaseConf.set("zookeeper.znode.parent", "/hbase")

    val connection = ConnectionFactory.createConnection(hbaseConf)

    val table = connection.getTable(TableName.valueOf("upai_tempData"))
    println(1)
    val rowKey = "4S"

    val rkGet = new Get(Bytes.toBytes(rowKey))

    val res = table.get(rkGet)
    println(table.exists(rkGet))
    table.close()
    connection.close()

  }

}


package spark.util;


import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisSentinelPool;
import redis.clients.util.Hashing;

import java.util.*;

/**
 * 用一致性哈希算法
 */
public class ShardedJedisSentinelPool {

    private static Map<String, JedisSentinelPool> poolMap = new HashMap<>();
    private static Hashing algo = Hashing.MURMUR_HASH;
    private static TreeMap<Long, String> nodes = new TreeMap<>();

    static {
        initPool();
    }
    private ShardedJedisSentinelPool(){

    }

    private static class SingletonInstance {

        private static final ShardedJedisSentinelPool INSTANCE = new ShardedJedisSentinelPool();
    }

    public static ShardedJedisSentinelPool getInstance() {

        return SingletonInstance.INSTANCE;
    }

    public static void initPool() {

        String[] masterNames = PropertiesLoader.getInstance().getProperty("redis.master.names").split(",");
        initialize(masterNames);

        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(Integer.parseInt(PropertiesLoader.getInstance().getProperty("redis.maxTotal")));// 最大连接数
        poolConfig.setMaxIdle(Integer.parseInt(PropertiesLoader.getInstance().getProperty("redis.maxIdle")));// 最大空闲数
        poolConfig.setMaxWaitMillis(Integer.parseInt(PropertiesLoader.getInstance().getProperty("redis.maxWait")));// 最大允许等待时间，如果超过这个时间还未获取到连接，则会报JedisException异常：Could not get a resource from the pool
        poolConfig.setTestOnBorrow(false);
        poolConfig.setTestOnReturn(false);
        String[] hostAndPortArray = PropertiesLoader.getInstance().getProperty("redis.cluster").split(",");
        Set<String> sentinels = new HashSet<>();
        for (int i = 0; i < hostAndPortArray.length; i++) {
            String host = hostAndPortArray[i].split(":")[0];
            int port = Integer.parseInt(hostAndPortArray[i].split(":")[1]);
            sentinels.add(new HostAndPort(host, port).toString());
        }

        String password = PropertiesLoader.getInstance().getProperty("redis.auth");
        for (String masterName : masterNames) {
            poolMap.put(masterName, new JedisSentinelPool(masterName, sentinels, poolConfig, password));
        }
        System.out.println("the redis shard cluster pool init success");
    }

    public static JedisSentinelPool getShardPool(String key) {

        String masterName = getShardInfo(key.getBytes());
        if (System.currentTimeMillis() % 500 == 1) {
           // System.out.println(key + "=" + masterName);
        }
        return poolMap.get(masterName);
    }

    public static Jedis getResource(String key) {

        return getShardPool(key).getResource();
    }

    private static void initialize(String[] masterNames) {

        for (int i = 0; i != masterNames.length; ++i) {
            for (int n = 0; n < 160; n++) {
                nodes.put(algo.hash("SHARD-" + i + "-NODE-" + n), masterNames[i]);
            }
        }
    }

    public static String getShardInfo(byte[] key) {

        SortedMap<Long, String> tail = nodes.tailMap(algo.hash(key));
        if (tail.isEmpty()) {
            return nodes.get(nodes.firstKey());
        }
        return tail.get(tail.firstKey());
    }

    public static void close() {
        for (Map.Entry<String, JedisSentinelPool> iter : poolMap.entrySet()) {
            iter.getValue().destroy();
        }
    }
}

package spark.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.*;

import java.util.Map;
import java.util.Set;

/**
 * @Description：redis分片连接池自动关闭连接工具类
 * @Author x
 * @CreateDate: 2019/3/18 10:31
 */
public class ShardRedisProxyUtils {

    private static final Logger logger = LoggerFactory.getLogger(ShardRedisProxyUtils.class);

    private static ShardedJedisSentinelPool shardPool = ShardedJedisSentinelPool.getInstance();

    private ShardRedisProxyUtils() {

    }

    public static Boolean exists(String key) {

        Jedis jedis = null;
        try {
            jedis = shardPool.getResource(key);
            return jedis.exists(key);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    public static Long del(String key) {

        Jedis jedis = null;
        try {
            jedis = shardPool.getResource(key);
            return jedis.del(key);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    public static void set(String key, String value, int seconds) {

        Jedis jedis = null;
        try {
            jedis = shardPool.getResource(key);
            Pipeline pipeline = jedis.pipelined();
            pipeline.set(key, value);
            pipeline.expire(key, seconds);
            pipeline.sync();
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    public static Long setnx(String key, String value) {

        Jedis jedis = null;
        try {

            jedis = shardPool.getResource(key);
            return jedis.setnx(key, value);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    public static Long expire(String key, int seconds) {

        Jedis jedis = null;
        try {

            jedis = shardPool.getResource(key);
            return jedis.expire(key, seconds);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    public static String get(String key) {

        Jedis jedis = null;
        try {

            jedis = shardPool.getResource(key);
            return jedis.get(key);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    public static String hget(String key, String field) {

        Jedis jedis = null;
        try {

            jedis = shardPool.getResource(key);
            return jedis.hget(key, field);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    public static Long hset(String key, String field, String value) {

        Jedis jedis = null;
        try {

            jedis = shardPool.getResource(key);
            return jedis.hset(key, field, value);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    public static Map<String, String> hgetAll(String key) {

        Jedis jedis = null;
        try {

            jedis = shardPool.getResource(key);
            return jedis.hgetAll(key);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    public static Long zadd(String key, double score, String menber) {

        Jedis jedis = null;
        try {

            jedis = shardPool.getResource(key);
            return jedis.zadd(key, score, menber);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }


    public static Set<Tuple> zrevrangeWithScores(String key, double min, double max) {
        Jedis jedis = null;
        try {

            jedis = shardPool.getResource(key);
            return jedis.zrangeByScoreWithScores(key, min, max);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }


    public static Long hdel(String key, String field) {

        Jedis jedis = null;
        try {

            jedis = shardPool.getResource(key);
            return jedis.hdel(key, field);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    public static ScanResult<Map.Entry<String, String>> hscan(String key, String cursor, ScanParams params) {

        Jedis jedis = null;
        try {

            jedis = shardPool.getResource(key);
            return jedis.hscan(key, cursor, params);
        } catch (Exception e) {
            throw e;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    /**
     * 关闭redis连接池
     */
    public static void close() {

        try {
            if (shardPool != null) {
                shardPool.close();
                System.out.println("close the redis shard pool success!");
            }
        } catch (Exception e) {
            logger.error("close the redis shard pool error:", e);
        }
    }
}


package spark.util;

import java.util.Map;

import com.sf.framework.cacheproxy.redis.RedisCache;
import com.sf.framework.cacheproxy.redis.RedisConfig;
import com.sf.framework.cacheproxy.redis.RedisType;

/**
 * @Description：redis分片连接池自动关闭连接工具类
 * @Author 01381119
 * @CreateDate: 2019/3/18 10:31
 */
public class RedisUtils {

    private RedisUtils() {

    }

    private static RedisCache redisCache = null;


    public static RedisCache getRedisCache() {

        if (redisCache != null) {
            return redisCache;
        }
        synchronized (RedisUtils.class) {
            if (redisCache != null) {
                return redisCache;
            }
            String nodesStr = PropertiesLoader.getInstance().getProperty("redis.cluster");
            String password = PropertiesLoader.getInstance().getProperty("redis.auth");
//            String nodesStr = "Up89A52y-1.cachesit.sfcloud.local:8080,Up89A52y-2.cachesit.sfcloud.local:8080,Up89A52y-3.cachesit.sfcloud.local:8080,Up89A52y-4.cachesit.sfcloud.local:8080,Up89A52y-5.cachesit.sfcloud.local:8080,Up89A52y-6.cachesit.sfcloud.local:8080";
//            String password = "RQtri9RwVb1oTc7km2QXjUgv";
            RedisConfig config = new RedisConfig();
            config.setServers(nodesStr);
            config.setPassword(password);
            config.setType(RedisType.CLUSTER);
            redisCache = new RedisCache(config);
        }
        return redisCache;
    }


    public static Boolean exists(String key) {
        RedisCache cache = getRedisCache();
        return cache.exists(key);
    }


    public static void set(String key, String value, int seconds) {
        RedisCache cache = getRedisCache();
        cache.set(key, value, seconds);
    }

    public static boolean setnx(String key, String value, int seconds) {
        RedisCache cache = getRedisCache();
        return cache.setnx(key, value, seconds);
    }

    public static void expire(String key, int seconds) {
        RedisCache cache = getRedisCache();
        cache.setTtl(key, seconds);
    }

    public static String get(String key) {
        RedisCache cache = getRedisCache();
        return cache.get(key);
    }

    public static String hget(String key, String field) {
        RedisCache cache = getRedisCache();
        return cache.hget(key, field);
    }

    public static void hset(String key, String field, String value, int seconds) {
        RedisCache cache = getRedisCache();
        cache.hset(key, field, value, seconds);
    }

    public static Map<String, String> hgetAll(String key) {
        RedisCache cache = getRedisCache();
        return cache.hgetAll(key);

    }

    public static void del(String key) {
        RedisCache cache = getRedisCache();
        cache.remove(key);
    }

    public static void shutdown() {
        RedisCache cache = getRedisCache();
        cache.shutdown();
    }

    public static void main(String[] args) {
        int threadCount = 1;
        for (int i = 0; i < threadCount; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    testWrite();
                }
            }).start();
        }
        sleep(10000000);
    }

    private static void testWrite() {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            String uuid = "";//UuidUtils.get();
            String key = "testkey" + uuid;
            String value = "testValue" + uuid;
            set(key, value, 6);
            sleep(5000);
            System.out.println(value + "\t" + get(key));
            sleep(1000);
            System.out.println(value + "\t" + get(key));
            if (i % 1000 == 0) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
        }
    }

    private static void sleep(long t) {
        try {
            Thread.sleep(t);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
lei729533667
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【三天掌握Spark】--外部数据源
weixin_48143996的博客
05-24 669
Spark之外部数据源 Spark与Hbase的交互 Spark可以从外部存储系统读取数据，比如RDBMs表中或者HBase表中读写数据，这也是企业中常常使用，如下两个场景： 1)要分析的数据存储在Hbase中，需要从中读取数据做数据分析 ~日志数据：操作日志等 ~订单数据 2）使用Spark进行离线分析后，往往将数据保存到Mysql中 ~ 网站的PV，UV，VV······· Spark如何从HBase数据库表中读（read：RDD）写（write：RDD）数据呢？？ ~ 加载数据：从HBas
Druid整合Spark Streaming
11-14
详细操作步骤,一步到位,代码完整,包括模拟数据发送,数据查询!
【多数据源连接】-Spring整合Hbase、Impala、Orcale三种数据源
weixin_38256991的博客
10-31 5313
       项目中需要按需连接不同的数据源，原项目默认为mysql连接，现在要添加Hbase、Impala、Orcale三种数据源，以支持现有的查询（属于报表子系统）。 MySql、Orcale、Impala是关系型数据库，可以用bean来配置连接池，方便、快捷的完成数据库访问。而Hbase属于列存储数据库，是一个NoSQL数据库，可存储大量非关系型数据。我们这里用phoenix来连接Hbase...
java hbase创建_HBase详解
weixin_39621044的博客
11-21 379
一、概述1.1 定义 HBase – Hadoop Database，是一个高可靠性、高性能、面向列、可伸缩、实时读写的分布式数据库。1.2 优点&缺点（与关系型数据库对比）优点海量存储良好的扩展性稀疏性 高性能多版本TTL缺点不支持复杂的聚合运算(Join、GroupBy等)没有二级索引 rowkey--设计不支持跨行事务1.3 版本变迁本课程采用的版本是1.4.10，目前HBase社...
使用SparkSQL读取Hbase表
qazwsx1225a的博客
12-05 6653
HBase-Spark Connector(在HBase-Spark 模块中）利用了在Spark-1.2.0中引入的DataSource API(SPARK-3247)，在简单的HBase KV存储和复杂的关系型SQL查询之间架起了桥梁，使得用户可以在HBase上使用Spark执行复杂的数据分析工作。HBase Dataframe是一个标准的Spark Dataframe，能够与任何其他的数据源进
大数据时代关系数据库MySQL的创新与发展.pdf
10-10
NoSQL数据库的出现，如MongoDB、Redis和HBase，为处理非结构化和半结构化数据提供了新的途径。NoSQL数据库支持分布式存储和并发读写，具有高可扩展性，尤其适用于互联网应用。然而，NoSQL的不足在于缺乏统一的标准，...
大数据时代关系数据库MySQL的创新与发展.docx
11-29
随着NoSQL数据库的崛起，例如MongoDB、Redis和HBase，它们在处理非结构化和不可预知数据方面表现出色，提供了高并发读写性能。然而，NoSQL系统缺乏标准化，数据耦合性弱，安全性不强，且不支持SQL和事务处理，这限制...
清华大学精品大数据实战课程（Hadoop、Hbase、Hive、Spark）PPT课件含习题（13页） 第1章 大数据概述.pptx
05-23
1. Key-Value存储：如Hbase、Voldemort，适用于大规模、高并发的键值对读写操作。 2. Key-Column存储：例如Hbase，以行和列族的方式存储数据，适合大数据分析。 3. Key-Value Cache：如Redis，用于高速缓存，提高...
参考资料-XX电信本地计费存储方案.zip
02-16
本地计费存储可能采用关系型数据库（如Oracle、MySQL）或非关系型数据库（如HBase、Cassandra）来存储海量数据。关系型数据库适合处理结构化数据，而非关系型数据库在处理大规模分布式数据时有优势。 3. **高性能...
Java及大数据学习路线.pdf
12-24
⼤数据存储框架Hadoop 分布式服务管理框架zookeeper hadoop⾼可⽤HA 数据仓库hive 数据查询框架impala+kudu+clouderManager ⽇志采集传输框架flume/idea 分布式发布-订阅消息系统Kafka+监控器kafkaManager+...
HBase连接池技术
进一步有一步的欢喜
04-26 2万+
先看官方文档的总体描述： hbase有两种获得connection的方法，分别是如下两种：      Connection connection = ConnectionFactory.createConnection(conf);      Connection connection = HConnectionManager.createConnection(conf);
mysql 分批提交_spark dataframe 数据批量写入 redis（pipeline、分批提交）
weixin_33016355的博客
02-01 1055
使用 python 的 spark 模块，即 pyspark，通过 spark sql 从 hive 或 mysql 等存储层读取相关数据，对应 spark 的 dataframe 对象，经过一系列的数据变化操作后(若需要)，将最终数据通过 pipeline，并利用 spark 的分布式形式分批写入 redis。推荐解决方式假设 dataframe 数据中 id 为其中一列，其余为对应的统计数据列...
Spark(35) -- SparkStreaming -- 概述
erainm
10-07 554
1. Streaming 应用场景 2. Lambda 架构 3. Streaming 计算模式 4. SparkStreaming 计算思想 5. 什么是Spark Streaming 6. 为什么要学习Spark Streaming 7. SparkStreaming与Storm的对比
Druid和ES查询结果通用解析方法
sxiaobei的博客
07-13 6423
做数据的同学相信大家对Druid和Es都不陌生，Druid可以说是一款基于时序的查询引擎，支持数据实时摄入，在数据摄入前指定维度和指标，提供基于时间层面的预聚合，Druid会把一个数据点当做一个实际发生的事实，在数据摄入后就不能修改。常被应用于一些实时的场景，比如对数据实时分时间段分组聚合。ES同样是一款高效的查询引擎，支持数据的批量导入，同样支持数据实时的摄入，也支持数据批量导入，相比于Drui...
Redis命令之HGetAll性能问题解决方案
热门推荐
u012538947的专栏
11-03 4万+
最近工作中，系统压测遇到一个性能瓶颈问题，通过最终排查，发现应用接口中使用了大量的Hgetall命令从Redis中查询数据信息，导致Redis单实例OPS达到秒钟7W次，Redis服务器CPU使用率达到上限，遇到性能问题。 HGETALL key 起始版本：2.0.0 时间复杂度：O(N) where N is the size of the hash. 返回 key 指定的哈希集中所有的...
使用Spark读写数据库与数据处理
qq_27746169的博客
10-14 1310
使用Spark读写数据库与数据处理编程语言数据库连接数据读取自建连接，单机读取使用spark的jdbc接口读取数据写入写入方法写入nginx服务器分区repartitioncoalesce调用函数配置文件集群运行处理办法优先级读取方法细节类型强转打包 编程语言 使用spark进行离线数据处理，可以使用Java、Scala、python等编程语言，但是pyspark的速度相比其他语言要慢上很多，首先...
druid读取hdfs文件
weixin_33758863的博客
11-13 1014
2019独角兽企业重金招聘Python工程师标准>>> ...
springboot项目java连接kerberos认证的hive和hbase，代码及报错问题解决
mathlpz126的博客
03-31 6290
项目部署要连接外部系统（如苏研平台）的大数据平台hive和hbase组件，大数据平台配置了kerberos安全认证，但对方没有提供相关的连接示例代码。 由于是第一次对接，部署调试过程中遇到很多问题，记录下来，仅供参考。 1、hive连接配置代码： /** * @return */ @Bean(name = "datasourceHive") public DataSource getDataSourceHive() { // .
Druid 一次海量数据实时处理的实践
crasheye的博客
08-22 1万+
Druid是一个用于大数据实时查询和分析的高容错、高性能开源分布式系统，旨在快速处理大规模的数据，并能够实现快速查询和分析
spark读写hbase
最新发布
07-29
回答: 要在Spark中读写HBase，你需要进行以下几个步骤。首先，你需要在simple.sbt配置文件中指定HBase的版本号，包括hbase-client、hbase-common和hbase-server的版本号。你可以通过在Linux系统中打开终端并导航到...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值