【Flink】Flink 自定义 redis sink

最新推荐文章于 2023-08-04 16:47:33 发布
最新推荐文章于 2023-08-04 16:47:33 发布
阅读量1.2k 收藏 7
点赞数 1
分类专栏： 大数据-flink 文章标签： flink redis 自定义 sink
原文链接：https://www.jianshu.com/p/09ed7e71aa1f
版权

在这里插入图片描述

1.概述

内部要做 Flink SQL 平台，本文以自定义 Redis Sink 为例来说明 Flink SQL 如何自定义 Sink 以及自定义完了之后如何使用
基于 Flink 1.11

2.步骤

  1. implements DynamicTableSinkFactory
  2. implements DynamicTableSink
  3. 创建 Redis Sink

3.自定义 sink 代码

import org.apache.flink.configuration.ConfigOption;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.configuration.ReadableConfig;
import org.apache.flink.streaming.api.functions.sink.PrintSinkFunction;
import org.apache.flink.streaming.api.functions.sink.RichSinkFunction;
import org.apache.flink.table.connector.ChangelogMode;
import org.apache.flink.table.connector.sink.DynamicTableSink;
import org.apache.flink.table.connector.sink.DynamicTableSink.DataStructureConverter;
import org.apache.flink.table.connector.sink.SinkFunctionProvider;
import org.apache.flink.table.data.RowData;
import org.apache.flink.table.factories.DynamicTableSinkFactory;
import org.apache.flink.table.factories.FactoryUtil;
import org.apache.flink.table.types.DataType;
import org.apache.flink.table.types.logical.RowType;
import org.apache.flink.types.Row;
import org.apache.flink.types.RowKind;
import redis.clients.jedis.JedisCluster;

import java.util.*;

import static org.apache.flink.configuration.ConfigOptions.key;


/**
 * @author shengjk1
 * @date 2020/10/16
 */
public class RedisTableSinkFactory implements DynamicTableSinkFactory {
    
    public static final String IDENTIFIER = "redis";
    
    public static final ConfigOption<String> HOST_PORT = key("hostPort")
            .stringType()
            .noDefaultValue()
            .withDescription("redis host and port,");
    
    public static final ConfigOption<String> PASSWORD = key("password")
            .stringType()
            .noDefaultValue()
            .withDescription("redis password");
    
    public static final ConfigOption<Integer> EXPIRE_TIME = key("expireTime")
            .intType()
            .noDefaultValue()
            .withDescription("redis key expire time");
    
    public static final ConfigOption<String> KEY_TYPE = key("keyType")
            .stringType()
            .noDefaultValue()
            .withDescription("redis key type,such as hash,string and so on ");
    
    public static final ConfigOption<String> KEY_TEMPLATE = key("keyTemplate")
            .stringType()
            .noDefaultValue()
            .withDescription("redis key template ");
    
    public static final ConfigOption<String> FIELD_TEMPLATE = key("fieldTemplate")
            .stringType()
            .noDefaultValue()
            .withDescription("redis field template ");
    
    
    public static final ConfigOption<String> VALUE_NAMES = key("valueNames")
            .stringType()
            .noDefaultValue()
            .withDescription("redis value name ");
    
    @Override
    // 当 connector 与 IDENTIFIER 一直才会找到 RedisTableSinkFactory 通过 
    public String factoryIdentifier() {
        return IDENTIFIER;
    }
    
    @Override
    public Set<ConfigOption<?>> requiredOptions() {
        return new HashSet<>();
    }
    
    @Override
    //我们自己定义的所有选项 (with 后面的 ) 都会在这里获取
    public Set<ConfigOption<?>> optionalOptions() {
        Set<ConfigOption<?>> options = new HashSet<>();
        options.add(HOST_PORT);
        options.add(PASSWORD);
        options.add(EXPIRE_TIME);
        options.add(KEY_TYPE);
        options.add(KEY_TEMPLATE);
        options.add(FIELD_TEMPLATE);
        options.add(VALUE_NAMES);
        return options;
    }
    
    @Override
    public DynamicTableSink createDynamicTableSink(Context context) {
        FactoryUtil.TableFactoryHelper helper = FactoryUtil.createTableFactoryHelper(this, context);
        helper.validate();
        ReadableConfig options = helper.getOptions();
        return new RedisSink(
                context.getCatalogTable().getSchema().toPhysicalRowDataType(),
                options);
    }
    
    
    private static class RedisSink implements DynamicTableSink {
        
        private final DataType type;
        private final ReadableConfig options;
        
        private RedisSink(DataType type, ReadableConfig options) {
            this.type = type;
            this.options = options;
        }
        
        @Override
        //ChangelogMode 
        public ChangelogMode getChangelogMode(ChangelogMode requestedMode) {
            return requestedMode;
        }
        
        @Override
        //具体运行的地方，真正开始调用用户自己定义的 streaming sink ，建立 sql 与 streaming 的联系
        public SinkRuntimeProvider getSinkRuntimeProvider(Context context) {
            DataStructureConverter converter = context.createDataStructureConverter(type);
            return SinkFunctionProvider.of(new RowDataPrintFunction(converter, options, type));
        }
        
        @Override
        // sink 可以不用实现，主要用来 source 的谓词下推
        public DynamicTableSink copy() {
            return new RedisSink(type, options);
        }
        
        @Override
        public String asSummaryString() {
            return "redis";
        }
    }
    
    /**
     同 flink streaming 自定义 sink ，只不过我们这次处理的是 RowData，不细说
     */
    private static class RowDataPrintFunction extends RichSinkFunction<RowData> {
        
        private static final long serialVersionUID = 1L;
        
        private final DataStructureConverter converter;
        private final ReadableConfig options;
        private final DataType type;
        private RowType logicalType;
        private HashMap<String, Integer> fields;
        private JedisCluster jedisCluster;
        
        private RowDataPrintFunction(
                DataStructureConverter converter, ReadableConfig options, DataType type) {
            this.converter = converter;
            this.options = options;
            this.type = type;
        }
        
        @Override
        public void open(Configuration parameters) throws Exception {
            super.open(parameters);
            logicalType = (RowType) type.getLogicalType();
            fields = new HashMap<>();
            List<RowType.RowField> rowFields = logicalType.getFields();
            int size = rowFields.size();
            for (int i = 0; i < size; i++) {
                fields.put(rowFields.get(i).getName(), i);
            }
            
            jedisCluster = RedisUtil.getJedisCluster(options.get(HOST_PORT));
        }

        @Override
        public void close() throws Exception {
            RedisUtil.closeConn(jedisCluster);
        }

        @Override
        /*
        2> +I(1,30017323,1101)
        2> -U(1,30017323,1101)
        2> +U(2,30017323,1101)
        2> -U(2,30017323,1101)
        2> +U(3,30017323,1101)
        2> -U(3,30017323,1101)
        2> +U(4,30017323,1101)
        3> -U(3,980897,3208)
        3> +U(4,980897,3208)
         */
        public void invoke(RowData rowData, Context context) {
            RowKind rowKind = rowData.getRowKind();
            Row data = (Row) converter.toExternal(rowData);
            if (rowKind.equals(RowKind.UPDATE_AFTER) || rowKind.equals(RowKind.INSERT)) {
                
                String keyTemplate = options.get(KEY_TEMPLATE);
                if (Objects.isNull(keyTemplate) || keyTemplate.trim().length() == 0) {
                    throw new NullPointerException(" keyTemplate is null or keyTemplate is empty");
                }
                
                if (keyTemplate.contains("${")) {
                    String[] split = keyTemplate.split("\\$\\{");
                    keyTemplate = "";
                    for (String s : split) {
                        if (s.contains("}")) {
                            String filedName = s.substring(0, s.length() - 1);
                            int index = fields.get(filedName);
                            keyTemplate = keyTemplate + data.getField(index).toString();
                        } else {
                            keyTemplate = keyTemplate + s;
                        }
                    }
                }
                
                String keyType = options.get(KEY_TYPE);
                String valueNames = options.get(VALUE_NAMES);
                // type=hash must need fieldTemplate
                if ("hash".equalsIgnoreCase(keyType)) {
                    String fieldTemplate = options.get(FIELD_TEMPLATE);
                    if (fieldTemplate.contains("${")) {
                        String[] split = fieldTemplate.split("\\$\\{");
                        fieldTemplate = "";
                        for (String s : split) {
                            if (s.contains("}")) {
                                String fieldName = s.substring(0, s.length() - 1);
                                int index = fields.get(fieldName);
                                fieldTemplate = fieldTemplate + data.getField(index).toString();
                            } else {
                                fieldTemplate = fieldTemplate + s;
                            }
                        }
                    }
                    
                    //fieldName = fieldTemplate-valueName
                    if (valueNames.contains(",")) {
                        HashMap<String, String> map = new HashMap<>();
                        String[] fieldNames = valueNames.split(",");
                        for (String fieldName : fieldNames) {
                            String value = data.getField(fields.get(fieldName)).toString();
                            map.put(fieldTemplate + "_" + fieldName, value);
                        }
                        jedisCluster.hset(keyTemplate, map);
                    } else {
                        jedisCluster.hset(keyTemplate, fieldTemplate + "_" + valueNames, data.getField(fields.get(valueNames)).toString());
                    }
                    
                } else if ("set".equalsIgnoreCase(keyType)) {
                    jedisCluster.set(keyTemplate, data.getField(fields.get(valueNames)).toString());
                    
                } else if ("sadd".equalsIgnoreCase(keyType)) {
                    jedisCluster.sadd(keyTemplate, data.getField(fields.get(valueNames)).toString());
                } else if ("zadd".equalsIgnoreCase(keyType)) {
                    jedisCluster.sadd(keyTemplate, data.getField(fields.get(valueNames)).toString());
                } else {
                    throw new IllegalArgumentException(" not find this keyType:" + keyType);
                }
                
                if (Objects.nonNull(options.get(EXPIRE_TIME))) {
                    jedisCluster.expire(keyTemplate, options.get(EXPIRE_TIME));
                }
            }
        }
    }
}

4.使用 Redis Sink

import org.apache.flink.api.java.tuple.Tuple3;
import org.apache.flink.api.java.typeutils.TupleTypeInfo;
import org.apache.flink.api.scala.typeutils.Types;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.streaming.api.CheckpointingMode;
import org.apache.flink.streaming.api.environment.ExecutionCheckpointingOptions;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.EnvironmentSettings;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;

import java.time.Duration;

/**
 * @author shengjk1
 * @date 2020/9/25
 */
public class SqlKafka {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        
        EnvironmentSettings environmentSettings = EnvironmentSettings.newInstance().useBlinkPlanner().inStreamingMode().build();
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env, environmentSettings);
        // enable checkpointing
        Configuration configuration = tableEnv.getConfig().getConfiguration();
        configuration.set(
                ExecutionCheckpointingOptions.CHECKPOINTING_MODE, CheckpointingMode.EXACTLY_ONCE);
        configuration.set(
                ExecutionCheckpointingOptions.CHECKPOINTING_INTERVAL, Duration.ofSeconds(10));
        
        String sql = "CREATE TABLE sourcedata (`id` bigint,`status` int,`city_id` bigint,`courier_id` bigint,info_index int,order_id bigint,tableName String" +
                ") WITH (" +
                "'connector' = 'kafka','topic' = 'xxx'," +
                "'properties.bootstrap.servers' = 'xxx','properties.group.id' = 'testGroup'," +
                "'format' = 'json','scan.startup.mode' = 'earliest-offset')";
        tableEnv.executeSql(sql);
        
        //15017284 distinct
        Table bigtable = tableEnv.sqlQuery("select distinct a.id,a.courier_id,a.status,a.city_id,b.info_index from (select id,status,city_id,courier_id from sourcedata where tableName = 'orders' and status=60)a join (select " +
                " order_id,max(info_index)info_index from sourcedata  where tableName = 'infos'  group by order_id )b on a.id=b.order_id");

        sql = "CREATE TABLE redis (info_index BIGINT,courier_id BIGINT,city_id BIGINT" +
                ") WITH (" +
                "'connector' = 'redis'," +
                "'hostPort'='xxx'," +
                "'keyType'='hash'," +
                "'keyTemplate'='test2_${city_id}'," +
                "'fieldTemplate'='test2_${courier_id}'," +
                "'valueNames'='info_index,city_id'," +
                "'expireTime'='1000')";
            
        tableEnv.executeSql(sql);
        
        Table resultTable = tableEnv.sqlQuery("select sum(info_index)info_index,courier_id,city_id from " + bigtable + " group by city_id,courier_id");
        TupleTypeInfo<Tuple3<Long, Long, Long>> tupleType = new TupleTypeInfo<>(
                Types.LONG(),
                Types.LONG(),
                Types.LONG());
        tableEnv.toRetractStream(resultTable, tupleType).print("===== ");
        tableEnv.executeSql("INSERT INTO redis SELECT info_index,courier_id,city_id FROM " + resultTable);
        env.execute("");
    }
}

5.详细解释

create table test(
`id` bigint,
 `url` string,
 `day` string,
  `pv` long,
  `uv` long
) with {
    'connector'='redis',
    'hostPort'='xxx',
    'password'='',
    'expireTime'='100',
    'keyType'='hash',
    'keyTemplate'='test_${id}',
    'fieldTemplate'='${day}',
    'valueNames'='pv,uv',
}

redis result: 假设 id=1 day=20201016 pv=20,uv=20
    hash
    test_1 20201016-pv 20,20201016-uv 20

参数解释：
connector  固定写法
hostPort   redis 的地址
password   redis 的密码
expireTime  redis key 过期时间，单位为 s
keyType  redis key 的类型，目前有 hash、set、sadd、zadd
keyTemplate  redis key 的表达式，如 test_${id} 注意 id 为表的字段名
fieldTemplate  redis keyType==hash 时，此选项为必选，表达式规则同 keyTemplate
valueNames  redis value  only 可以有多个

6.原理

在这里插入图片描述

整个流程如图，CatalogTable —> DynamicTableSource and DynamicTableSink 这个过程中，其实是通过 DynamicTableSourceFactory and DynamicTableSinkFactory 起到了一个桥梁的作用

(Source/Sink)Factory 通过 connector=‘xxx’ 找到，理论上会做三种操作

  1. validate options
  2. configure encoding/decoding formats( if required )
  3. create a parameterized instance of the table connector
    其中 formats 是通过 format=‘xxx’ 找到

DynamicTableSource DynamicTableSink
官网虽说可以看做是有状态的，但是否真的有状态取决于具体实现的 source 和 sink

生成 Runtime logic，Runtime logic 被 Flink core connector interfaces( 如 InputFormat or SourceFunction)，如果是 kafka 的话 则 是 FlinkKafkaConsumer 实现，而这些实现又被抽象为 *Provider，然后开始执行 *Provider

*Provider 是连接 SQL 与 Streaming 代码级别的桥梁

7.参考
https://ci.apache.org/projects/flink/flink-docs-release-1.11/dev/table/sourceSinks.html

作者：学木
链接：https://www.jianshu.com/p/09ed7e71aa1f
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

九师兄
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
订阅专栏
FLINK 基于1.15.2的Java开发-自定义Redis Sink用于连接 Redis Sentinel模式
lifetragedy的专栏
10-04 1421
通过自定义flink的redis sink组件实现连接sentinel-哨兵模式以及自定义自己的redis读写业务逻辑。同时通过这一个例子，把之前的读kafka、反序列化、日志功能全部集成在一个例子中，这个例子就是一个完备的并可以适用于真实生产的实际例子。
Flink笔记(二十四)：Flink 数据 保存 Redis(自定义Redis Sink)
01-07
本文主要来介绍 Flink 读取 Kafka数据，并实时下沉(Sink)数据到 Redis 的过程。        通过如下链接：Flink官方文档，我们知道数据保存到 Redis 的容错机制是 at least once。所以我们通过幂等操作，使用新数据覆盖旧数据的方式，以此来实现 exactly-once 。 1.代码部分 1.1 config.properties配置文件 bootstrap.server=192.168.204.210:9092,192.168.204.211:9092,192.168.204.212:9092 group.id=testGroup auto.offse
Flink Redis Sink
qq_24095055的博客
10-28 1692
文章目录官方API自定义Redis Sink 官方API flink提供了专门操作redis的Redis Sink 依赖 <dependency> <groupId>org.apache.bahir</groupId> <artifactId>flink-connector-redis_2.11</artifactId> <version>1.0</version> </dependency&
16-Flink-Redis-Sink
weixin_34150503的博客
03-06 196
戳更多文章： 1-Flink入门 2-本地环境搭建&构建第一个Flink应用 3-DataSet API 4-DataSteam API 5-集群部署 6-分布式缓存 7-重启策略 8-Flink中的窗口 9-Flink中的Time 简介 流式计算中，我们经常有一些场景是消费Kafka数据，进行处理，然后存储到其他的数据库或者缓存或者重新发送回其他的消息队列中。 本文讲述一个简单的Redi...
Flink如何自定义Redis的Sink
top8488.top大数据
09-16 286
背景 Flink 默认的 RedisMapper 不能设置key的过期时间。 依赖 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> SinkFunction & RichSinkFunct
Flink Redis Sink 自定义
热门推荐
小杨的技术博客
03-27 3万+
文章目录背景依赖SinkFunction & RichSinkFunctionDemo 背景 Flink 默认的 RedisMapper 不能设置key的过期时间。 依赖 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactI...
flink-redis-sink:使用TableSQL API帮助沉入Redis
05-26
该项目用于使用表或sql api将数据写入flink流应用程序中的redis。 之前，我看到了项目，该项目具有一个模块来帮助使用flink写入redis。 但是，它可以工作，但与我的愿望并不完全匹配。 当我想将行/表沉入redis中时： Firstly,i'd like to choose one or more field as the redis key, Secondly, i'd like to take the row as a map or json string as the value. Thirdly, watermark needs to be supported too. 但是，如果不更改源代码，它看起来并不容易。 我想写我自己的redis-sink。 当您查看此项目时，有一些技巧需要记住： 该项目仅支持REDIS CLUSTER模式。 该项目使用redi
flink-connector-redis_2.11-1.1-SNAPSHOT
10-14
flink连接redis作为sink，1.0无法支持过期的时间，所以就有了这个jar包，支持过期的时间，避免你自己的重新编译，节省时间
Flink1.9系列-connnector-redis篇
01-07
前面kafka+flink的流程稍后会专门来写，本篇主要写flink sink redis技术 1. Redis数据结构 Redis的数据结构常用的无非就是两种： SET HSET 这里并不展开说这两种数据结构的具体定义和使用场景，主要针对这两种数据...
flink入门到精通视频教程
07-15
16.DataSink-输出数据到mysql,kafka,Redis 第六章 Flink中Window 01.为什么需要window 02.什么是window 03.Flink支持的窗口划分方式 04.Time-window之tumbling-time-window 05.Time-window之sliding-time-window 06....
flink之自定义Sink（写入redis为例）
weixin_43742510的博客
07-20 267
官网有直接写入redis的依赖，我们不用，用自定义sink的方式写入redis。通过富函数创建和关闭连接。
第二十七篇：Flink Redis Sink 实现
微信搜：import_bigdata，大数据领域硬核原创作者
07-24 605
你好，欢迎来到第 27 课时，本课时主要讲解 Flink 使用 Redis 作为 Sink 的设计和实现。 我们在第 12 课时“Flink 常用的 Source 和 Connector”中提过 Flink 提供了比较丰富的用来连接第三方的连接器，可以在官网中找到 Flink 支持的各种各样的连接器。 此外，Flink 还会基于 Apache Bahir 发布一些 Connector，其中就有我们非常熟悉的 Redis。很多人在 Flink 项目中访问 Redis 的方法都是自己进行实现的，我们也可以使用
FLINK redis sink的使用
dieqianpan9257的博客
04-10 344
对redis的HSET操作，可以参考官方文档，此处不再缀述 https://bahir.apache.org/docs/flink/current/flink-streaming-redis/ 项目中，需要使用ZADD操作，此处记录一下，如果使用redis的其他指令，应该如何使用 从官方demo中，可以看到，添加sink的代码 stream.addSink(new RedisSi...
Flink之redis sink
啥也不会的博客
05-17 2101
1.导入依赖 <!-- https://mvnrepository.com/artifact/org.apache.bahir/flink-connector-redis --> <dependency> <groupId>org.apache.bahir</groupId> <artifactId>flink-connector-redis_2.11</artifactId> <version>
Flink之RedisSink
AnameJL的博客
08-04 1266
Flink将数据写入Redis
Flink—RedisSink
popping_w的博客
08-27 344
Flink—RedisSink 1.开发流程 特别说明： Flink版本1.12 Reids不是跟着Flink版本的走的，相当于有第三方提供的工具类。 2.环境介绍 idea+liunx 添加Redis Connector依赖 <!-- https://mvnrepository.com/artifact/org.apache.flink/flink-connector-redis --> <dependency> <groupId>org.apache.fli
Flink1.10入门：自定义Redis的Sink函数
陆继森的技术专栏
05-06 1024
微信公众号：大数据开发运维架构 关注可了解更多大数据相关的资讯。问题或建议，请公众号留言; 如果您觉得“大数据开发运维架构”对你有帮助，欢迎转发朋友圈 从微信公众号拷贝过来，格式有些错乱，建议直接去公众号阅读 一、概述 这篇文章需要完成的是将实时数据写到Redis，我这里自定义了Ridis对应的Sink函数，为了方便直接从socket端接收数据，operator处理后，直接写入r...
flink 实现redis sink
daqu1314的博客
02-16 814
最近,记录下这些常用的redis es 在fink中作为sink的使用方式,方便,后来使用 1.data数据 sensor_1,1547718199,35.8 sensor_6,1547718201,15.4 sensor_7,1547718202,6.7 sensor_10,1547718205,38.1 sensor_1,1547718207,36.3 sensor_1,1547718209,32.8 sensor_1,1547718212,37.1 sensor_1,1547718199,35.
flink redis集群 sink
最新发布
09-06
Flink Redis集群Sink是将Flink流处理的结果写入Redis集群中的一种方式。Redis是一种常用的开源内存数据结构存储系统，具有高性能、高可用性和可扩展性的特点。 Flink是一个流计算框架，具有并行计算、分布式处理和容错性等特点。在Flink中，可以通过使用RedisSink来实现将计算结果写入Redis集群。RedisSink提供了将数据写入Redis的接口和配置信息。用户可以根据需求设置Redis的连接信息、数据类型以及序列化方式等。 在使用Redis集群Sink时，需要注意以下几点： 1. 连接配置：需要提供Redis集群的连接信息，包括IP地址、端口号、密码等。如果Redis集群中有多个节点，则需要提供其中一个节点的信息即可。 2. 数据类型：Redis支持多种数据类型，包括字符串、哈希表、列表、集合和有序集合等。根据需要将数据写入相应的数据类型中。 3. 序列化方式：数据在传输和存储时一般需要进行序列化，需要选择合适的序列化方式，如JSON、Avro或Protobuf等。 4. 批量写入：为了提高性能，可以考虑将数据批量写入Redis，而不是逐条写入。可以根据实际情况设置每次写入的数据量。 使用Flink Redis集群Sink可以实现高效、可靠地将Flink流处理的结果写入Redis集群，使得计算结果可以随时被其他系统或服务查询和使用。同时，Redis集群的高可用性和可扩展性也能保证数据的安全和可持续处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值