Riak - 使用篇（1）

最新推荐文章于 2021-08-12 19:23:48 发布
最新推荐文章于 2021-08-12 19:23:48 发布
阅读量497 收藏 1
点赞数
文章标签： netty 数据库 json

分布式高可用键值对数据库Riak - 使用篇（1）

请先参考Riak - 安装运维篇（1）安装部署并启动Riak集群（3个Node）。
Riak默认有两种端口，一种是protobuf端口，还有一种是HTTP Restful端口。
以前的Riak client java API会支持两种端口。最新的Riak client Java API作了很多改造，比如说利用netty4作为网络通信框架，简化了API代码，并且只支持Protobuf端口。理由如下：

  1. 利用Protocol Buffers端口会快25%左右
  2. HTTP接口不支持基于证书的认证
  3. HTTP协议抽象不够详细

我们之后主要使用riak client2.0.5和Riak的protobuf端口进行开发使用Riak客户端，在某些情况下，会穿插一些Restful端口使用。因为某些功能在riak client2.0.5还未实现或者实现的不完整：

  1. MapReduce
  2. 二级索引查询
  3. 列出所有keys
  4. 列出所有buckets

1. 建立与Riak集群的连接

建立maven项目，添加如下依赖：

<properties>
    <!-- NIO framework -->
    <netty_version>5.0.0.Alpha2</netty_version>
    <!-- riak -->
    <riak-client_version>2.0.5</riak-client_version>
    <!-- Encoding -->
    <!-- fast json -->
    <jackson-core_version>2.7.3</jackson-core_version>
    <!-- log -->
    <slf4j_version>1.7.2</slf4j_version>
</properties>
<dependencies>
   <dependency>
       <groupId>com.basho.riak</groupId>
       <artifactId>riak-client</artifactId>
       <version>${riak-client_version}</version>
   </dependency>
   <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
       <version>${netty_version}</version>
   </dependency>
   <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-log4j12</artifactId>
       <version>${slf4j_version}</version>
   </dependency>
   <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-core</artifactId>
       <version>${jackson-core_version}</version>
   </dependency>
</dependencies>

之后新建ClusterRiakClient类：

package io.timberwolf.cache;

import com.basho.riak.client.api.RiakClient;
import com.basho.riak.client.api.cap.Quorum;
import com.basho.riak.client.api.commands.kv.FetchValue;
import com.basho.riak.client.api.commands.kv.StoreValue;
import com.basho.riak.client.core.RiakCluster;
import com.basho.riak.client.core.RiakNode;
import com.basho.riak.client.core.query.Location;
import com.basho.riak.client.core.query.Namespace;

import java.net.UnknownHostException;
import java.util.LinkedList;
import java.util.concurrent.ExecutionException;

/**
 * The client class of Riak
 *
 * @author Hash Zhang
 * @version 0.0.0
 * @see @https://github.com/basho/riak-java-client/wiki/RiakClient-%26-Cluster-Node-Builders-%28v2.0%29
 */
//implements AutoCloseable是为了利用Java7的新特性，try-with-resources
public class ClusterRiakClient implements AutoCloseable{
    private final static int DEFAULTMAXCONNECTIONS = 50;
    private final static int DEFAULTMINCONNECTIONS = 10;
    private final static int RETRIES = 5;

    private int maxConnections = DEFAULTMAXCONNECTIONS;
    private int minConnections = DEFAULTMINCONNECTIONS;
    private int retries = DEFAULTMINCONNECTIONS;

    private RiakClient riakClient;

    /**
     * 构建Riak集群的客户端
     *
     * @param hosts (hosts格式：127.0.0.1:10017,127.0.0.1:10027,127.0.0.1:10037)
     * @throws UnknownHostException
     */
    public ClusterRiakClient(String hosts) throws UnknownHostException {
        String[] addresses = hosts.split(",");
        //使用RiakNode Builder用于构建每个RiakNode
        RiakNode.Builder riakNodeBuilder = new RiakNode.Builder()
                .withMinConnections(minConnections)
                .withMaxConnections(maxConnections);
        //构建每个RiakNode并保存在list中
        LinkedList<RiakNode> nodes = new LinkedList<RiakNode>();
        for (int i = 0; i < addresses.length; i++) {
            int j = addresses[i].indexOf(":");
            nodes.add(riakNodeBuilder.withRemoteAddress(addresses[i].substring(0, j))
                    .withRemotePort(Integer.parseInt(addresses[i].substring(j + 1))).build());
        }
        //构建Riak集群并启动，注意，必须调用start()
        RiakCluster riakCliuster = RiakCluster.builder(nodes).withExecutionAttempts(retries).build();
        riakCliuster.start();
        riakClient = new RiakClient(riakCliuster);
    }
    public void close() throws Exception {
        riakClient.shutdown();
    }
}

将控制台（Console）日志级别设为debug，编写测试main：

public static void main(String[] args) throws Exception {
    ClusterRiakClient clusterRiakClient = new ClusterRiakClient("10.202.44.206:10017,10.202.44.206:10027,10.202.44.206:10037");
    clusterRiakClient.close();
}

运行，查看控制台输出

04-21 08:38:40.061   INFO [main] (RiakNode.java:282) -RiakNode started; 10.202.44.206:10017
04-21 08:38:40.147   INFO [main] (RiakNode.java:282) -RiakNode started; 10.202.44.206:10027
04-21 08:38:40.173   INFO [main] (RiakNode.java:282) -RiakNode started; 10.202.44.206:10037
04-21 08:38:40.174   INFO [main] (RiakCluster.java:142) -RiakCluster is starting.
04-21 08:38:40.175   INFO [main] (RiakCluster.java:149) -RiakCluster is shutting down.
04-21 08:38:40.677   INFO [pool-1-thread-2] (RiakCluster.java:428) -All operations have completed
04-21 08:38:40.677   INFO [pool-1-thread-2] (RiakNode.java:291) -RiakNode shutting down; 10.202.44.206:10017
04-21 08:38:40.677   INFO [pool-1-thread-1] (RiakCluster.java:416) -Retrier shutting down.
04-21 08:38:40.677   INFO [pool-1-thread-2] (DefaultNodeManager.java:159) -NodeManager removed node due to it shutting down; 10.202.44.206:10017
04-21 08:38:40.683   INFO [pool-1-thread-2] (RiakNode.java:291) -RiakNode shutting down; 10.202.44.206:10027
04-21 08:38:40.683   INFO [pool-1-thread-2] (DefaultNodeManager.java:159) -NodeManager removed node due to it shutting down; 10.202.44.206:10027
04-21 08:38:40.685   INFO [pool-1-thread-2] (RiakNode.java:291) -RiakNode shutting down; 10.202.44.206:10037
04-21 08:38:40.685   INFO [pool-1-thread-2] (DefaultNodeManager.java:159) -NodeManager removed node due to it shutting down; 10.202.44.206:10037
04-21 08:38:40.688   INFO [pool-1-thread-1] (RiakCluster.java:305) -RiakCluster has shut down

可以看出，Riak集群连接成功，并成功关闭连接。
如果日志级别为Debug，你可以看出，Riak客户端使用了Netty客户端连接的Riak集群
这里，Riakclient和RiakCluster还有实际的Riak集群之间的关系如下图所示：
这里写图片描述

2. 将值放在桶中

Riak是一种键值的存储方式，所以必须提供键值对才能保存数据。为了防止键冲突，Riak运用了桶的概念，用户可以将键放入不同的桶中（相当于键的namespace）

首先，我们建立一个简单的POJO类，保存快递员的基本信息。

/**
 * User POJO
 *
 * @author Hash Zhang
 * @version 0.0.0
 */
public class User {
    private String username;
    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

在ClusterRiakClient中添加如下方法：

/**
 * * 插入POJO对象
 *
 * @param bucket 桶
 * @param key    键
 * @param value  值
 * @throws ExecutionException
 * @throws InterruptedException
 * @throws JsonProcessingException
 */
public void set(String bucket, String key, Object value) throws ExecutionException, InterruptedException, JsonProcessingException {
    Location location = new Location(new Namespace(bucket), key);
    RiakObject riakObject = new RiakObject();
    riakObject.setValue(BinaryValue.create(OBJECT_MAPPER.writeValueAsBytes(value)));
    StoreValue sv = new StoreValue.Builder(riakObject).withLocation(location).build();
    StoreValue.Response svResponse = this.riakClient.execute(sv);
}

/**
 * 取得POJO对象
 *
 * @param bucket 桶
 * @param key    键
 * @return FetchValue.Response
 * @throws ExecutionException
 * @throws InterruptedException
 */
public RiakObject get(String bucket, String key) throws ExecutionException, InterruptedException {
    Location location = new Location(new Namespace(bucket), key);
    FetchValue fv = new FetchValue.Builder(location).build();
    return this.riakClient.execute(fv).getValue(RiakObject.class);
}

Location通过Bucket和Key确定唯一位置。编写测试main

public static void main(String[] args) throws Exception {
    ClusterRiakClient clusterRiakClient = new ClusterRiakClient("10.202.44.206:10017,10.202.44.206:10027,10.202.44.206:10037");
    User user1 = new User();
    user1.setUsername("zhxhash").setPassword("123456");
    clusterRiakClient.set("users", "user1", user1);
    RiakObject riakObject = clusterRiakClient.get("users", "user1");
    User getUser1 = OBJECT_MAPPER.readValue(riakObject.getValue().getValue(),User.class);
    System.out.println(getUser1.getUsername()+"|"+getUser1.getPassword());
    clusterRiakClient.close();
}

结果：

04-21 09:31:03.213   INFO [main] (RiakNode.java:282) -RiakNode started; 10.202.44.206:10017
04-21 09:31:03.240   INFO [main] (RiakNode.java:282) -RiakNode started; 10.202.44.206:10027
04-21 09:31:03.264   INFO [main] (RiakNode.java:282) -RiakNode started; 10.202.44.206:10037
04-21 09:31:03.266   INFO [main] (RiakCluster.java:142) -RiakCluster is starting.
zhxhash|123456
04-21 09:31:04.048   INFO [main] (RiakCluster.java:149) -RiakCluster is shutting down.
04-21 09:31:04.549   INFO [pool-1-thread-2] (RiakCluster.java:428) -All operations have completed
04-21 09:31:04.549   INFO [pool-1-thread-2] (RiakNode.java:291) -RiakNode shutting down; 10.202.44.206:10017
04-21 09:31:04.549   INFO [pool-1-thread-2] (DefaultNodeManager.java:159) -NodeManager removed node due to it shutting down; 10.202.44.206:10017
04-21 09:31:04.555   INFO [pool-1-thread-2] (RiakNode.java:291) -RiakNode shutting down; 10.202.44.206:10027
04-21 09:31:04.556   INFO [pool-1-thread-2] (DefaultNodeManager.java:159) -NodeManager removed node due to it shutting down; 10.202.44.206:10027
04-21 09:31:04.558   INFO [pool-1-thread-2] (RiakNode.java:291) -RiakNode shutting down; 10.202.44.206:10037
04-21 09:31:04.558   INFO [pool-1-thread-2] (DefaultNodeManager.java:159) -NodeManager removed node due to it shutting down; 10.202.44.206:10037
04-21 09:31:04.562   INFO [pool-1-thread-2] (RiakCluster.java:305) -RiakCluster has shut down
04-21 09:31:04.564   INFO [pool-1-thread-1] (RiakCluster.java:416) -Retrier shutting down.

以上是比较简单的增加和查询的实现，还有异步实现的方式。

/**
     * 异步插入POJO对象
     *
     * @param bucket 桶
     * @param key    键
     * @param value  值
     * @return RiakFuture<StoreValue.Response, Location>
     * @throws JsonProcessingException
     */
public RiakFuture<StoreValue.Response, Location> asyncSet(String bucket, String key, Object value) throws JsonProcessingException {
    Location location = new Location(new Namespace(bucket), key);
    RiakObject riakObject = new RiakObject();
    riakObject.setValue(BinaryValue.create(OBJECT_MAPPER.writeValueAsBytes(value)));
    StoreValue sv = new StoreValue.Builder(riakObject).withLocation(location).build();
    return this.riakClient.executeAsync(sv);
}
/**
 * 异步取得POJO对象
 *
 * @param bucket
 * @param key
 * @return RiakFuture<FetchValue.Response, Location>
 */
public RiakFuture<FetchValue.Response, Location> asyncGet(String bucket, String key) {
    Location location = new Location(new Namespace(bucket), key);
    FetchValue fv = new FetchValue.Builder(location).build();
    return this.riakClient.executeAsync(fv);
}

测试代码：

public static void main(String[] args) throws Exception {
    final ClusterRiakClient clusterRiakClient = new ClusterRiakClient("10.202.44.206:10017,10.202.44.206:10027,10.202.44.206:10037");
    final CountDownLatch countDownLatch = new CountDownLatch(1);
    Thread thread = new Thread() {
        @Override
        public void run() {
            User user1 = new User();
            user1.setUsername("zhxhash").setPassword("123456");
            RiakFuture<StoreValue.Response, Location> riakFuture = null;
            while(true) {
                try {
                    riakFuture = clusterRiakClient.asyncSet("users", "user1", user1);
                    riakFuture.await(100L, TimeUnit.MILLISECONDS);
                } catch (JsonProcessingException | InterruptedException e) {
                    e.printStackTrace();
                }
                if (riakFuture.isDone() && riakFuture.isSuccess())
                {
                    countDownLatch.countDown();
                    break;
                }
            }
        }
    };
    thread.start();
    countDownLatch.await();
    RiakFuture<FetchValue.Response, Location> riakFuture = null;
    while(true) {
        try {
            riakFuture = clusterRiakClient.asyncGet("users", "user1");
            riakFuture.await(100L, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (riakFuture.isDone() && riakFuture.isSuccess())
        {
            RiakObject riakObject = riakFuture.get().getValue(RiakObject.class);
            User getUser1 = OBJECT_MAPPER.readValue(riakObject.getValue().getValue(),User.class);
            System.out.println(getUser1.getUsername()+"|"+getUser1.getPassword());
            break;
        }
    }
    clusterRiakClient.close();
}

输出结果和之前同步的应该一样。
我们还可以删除某个键值对，同样的，有同步和异步两种实现：

/**
 * 删除一个键值对
 *
 * @param bucket 桶
 * @param key    键
 * @throws ExecutionException
 * @throws InterruptedException
 */
public void remove(String bucket, String key) throws ExecutionException, InterruptedException {
    Location location = new Location(new Namespace(bucket), key);
    DeleteValue dv = new DeleteValue.Builder(location).build();
    this.riakClient.execute(dv);
}

/**
 * 异步删除一个键值对
 *
 * @param bucket 桶
 * @param key    键
 * @return RiakFuture<Void, Location>
 */
public RiakFuture<Void, Location> asyncRemove(String bucket, String key){
    Location location = new Location(new Namespace(bucket), key);
    DeleteValue dv = new DeleteValue.Builder(location).build();
    return this.riakClient.executeAsync(dv);
}

测试：

public static void main(String[] args) throws Exception {
        ClusterRiakClient clusterRiakClient = new ClusterRiakClient("10.202.44.206:10017,10.202.44.206:10027,10.202.44.206:10037");
        clusterRiakClient.remove("users", "user1");
        RiakObject riakObject = clusterRiakClient.get("users", "user1");
        if (riakObject!=null) {
            User getUser1 = OBJECT_MAPPER.readValue(riakObject.getValue().getValue(), User.class);
            System.out.println(getUser1.getUsername() + "|" + getUser1.getPassword());
        } else{
            System.out.println("Not Found");
        }
        clusterRiakClient.close();
}

更新比较特殊，我们放到之后的章节去说
取得一个bucket下的所有键：

/**
 * 取得一个bucket下所有键
 *
 * @param bucket 桶
 * @return List<String>
 * @throws ExecutionException
 * @throws InterruptedException
 */
public List<String> getKeys(String bucket) throws ExecutionException, InterruptedException {
    Namespace ns = new Namespace(bucket);
    ListKeys lk = new ListKeys.Builder(ns).build();
    ListKeys.Response response = this.riakClient.execute(lk);
    List<String> keys = new LinkedList<>();
    for (Location l : response)
    {
        keys.add(l.getKeyAsString());
    }
    return keys;
}
<script type="text/javascript"> $(function () { $('pre.prettyprint code').each(function () { var lines = $(this).text().split('\n').length; var $numbering = $('<ul/>').addClass('pre-numbering').hide(); $(this).addClass('has-numbering').parent().append($numbering); for (i = 1; i <= lines; i++) { $numbering.append($('<li/>').text(i)); }; $numbering.fadeIn(1700); }); }); </script>
iteye_20566
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
riak-admin:Riak 的类似蒲团的 Web 界面
06-12
riak-admin 到目前为止的功能 显示桶的内容 单击时显示文档内容 编辑文档内容（json.object） 删除单个文档或存储桶的所有文档 用法 git clone git://github.com/frank06/riak-admin cd riak-admin && git ...
riak-cli:Riak 命令行客户端
07-11
带有 NodeJS 的 Riak 命令行工具。 有更好的解决方案，请参考 ->使用带有curl的Riak http api查询... $ riak-cli -m post -b bucket-name -k riak-key -d data$ riak-cli -m post -b bucket-name -k riak-key -f ${YO
Riak 简介，第 1 部分: 与语言无关的 HTTP API
zhangxinrun的专栏
08-17 4872
转载：http://www.ibm.com/developerworks/cn/opensource/os-riak1/index.html 简介 典型的现代关系数据库在某些类型的应用程序中表现平平，难以满足如今的互联网应用程序的性能和可扩展性要求。因此，需要采用不同的方法。在过去几年中，一种新的数据存储类型变得非常流行，通常称为 NoSQL，因为它可以直接解决关系数据库的一些缺陷
Riak - 背景篇（3）
iteye_20566的博客
04-19 320
分布式高可用键值对数据库Riak - 背景篇（3） Dynamo对于数据版本的处理 数据版本问题不止存在于分布式系统，这里针对分布式数据库系统简单讨论下。先看一个简单的例子，用户x对key1做了一次写入操作，我们设值是数字3。然后用户y读取了key1，这个时候用户y知道的值是3。然后用户x对值做了一个+1操作，将新值写入，现在key1的值是4了。而用户y也做了一次+1操作，然后写入，因为用户...
riak文件服务器,riak简介(一)
weixin_29090677的博客
08-12 904
本人机子为ubuntu。所以安装比较简单sudo apt-get install opensslsudo apt-get install erlang下载deb包安装wget -c http://s3.amazonaws.com/downloads.basho.com/riak/2.0/2.0.2/ubuntu/trusty/riak_2.0.2-1_amd64.debdpkg -i riak_2...
七天内七个数据库– Riak
danpu0978的博客
04-20 282
在这篇文章中，我总结了Riak的三天时间，这是“ 七天七数据库”一书中的第二个数据库。 这篇文章实际上是为了让我记住在阅读本章时所做的一些调整，因为有时这本书并不完全正确。 我使用了一个很好的博客，网址为： http : //blog.wakatta.jp/blog/2011/12/09/seven-databases-in-seven-weeks-riak-day-3/ （此链接指向第...
riak-session-manager.zip
07-19
riak-session-manager 是使用 Riak 来存储 Tomcat session 信息的项目。 配置方法：   <?xml version="1.0" encoding="UTF-8"?> <Manager className="com.jbrisbin.vpc.riak.session.RiakManager" ...
riak-cache:riak-cache 是一个 ActiveSupport
06-14
Riak 的 Rails/ActiveSupport 缓存存储（riak-cache） riak-cache是ActiveSupport::Cache::Store一个实现， ActiveSupport::Cache::Store在 Riak 中存储缓存值。 如果您已将 Riak 配置为使用内存后端，这将特别有用...
riak-java-client：Java的Riak客户端
02-19
Riak Java客户端 Riak Java客户端支持与 （开放源代码，分布式数据库）进行通信，该数据库专注于高可用性，水平可伸缩性和可预测的延迟。 Riak和此代码均由维护。... < artifactId>riak-client</ arti
Riak 学习文档
06-20
学习使用Riak
riak-ruby-client, 用于 ruby的Riak客户端.zip
09-18
riak-ruby-client, 用于 ruby的Riak客户端 ) 客户端( Riak客户机)riak-client 是一个富 ruby 客户端/工具箱，分布在，数据库中，包含典型操作的基本包装。在 http://basho.github.io/riak-ruby-client/ 可以使用详尽的文档
riak MapReduce 中的 {index, bucket(), Index::binary(), key()} 使用方法
langxianwu的专栏
07-16 130
  －－－－－－－－－－这是客户端测试代码－－－－－－－－－－－－－－－－－－－－－－－－－ -module(test). -export([test/0,          get_state/0]).   get_state() -&gt;     Bucket = &lt;&lt;"ejabberd/pubsub_state"&gt;&gt; ,     {ok, Pid}=...
Riak 简介，第 2 部分: 将 Riak 集成为 Web 应用程序的重负荷缓存服务器
zhangxinrun的专栏
08-17 1509
转载：http://www.ibm.com/developerworks/cn/opensource/os-riak2/ 简介 某些类型的数据表现出使自己适合于被缓存的访问模式。例如，在线投注站点具有一个有趣的负载特征：用户常常请求提供赔率和投注单，而这些信息相对来说很少被更新。 本系列中的其他文章 查看 Riak 简介 系列中的更多文章。 这些情况需要具
Riak介绍
weixin_34268579的博客
09-21 352
Riak是参照dynamo实现的一个分布式NoSQL数据存储系统,刚接触Riak首先要清楚Riak_Core跟Riak_KV的区别。 Riak把系统的管理层和存储层分开,前者是Riak_Core，后者是Riak_KV: Riak_Core的github地址:https://github.com/basho/riak_core, Riak_KV的github地址:ht...
riak优点_Riak TS用于大规模时间序列分析
cumo3681的博客
06-21 432
riak安装 直到最近，大规模的时间序列分析还是很昂贵的，而且几乎完全是大型企业的领域。 是什么使时间序列成为难以解决且昂贵的问题？ 在NoSQL数据库出现之前，进行扩展以满足不断增长的数据速度和数据量通常意味着通过添加CPU，内存或其他硬盘来垂直扩展硬件。 当与按处理器核心计费的数据库许可模型结合使用时，大多数情况根本无法实现扩展成本。 幸运的是，开源社区正在使大规模数据分析Swift民主...
Riak - 背景篇（2）
iteye_20566的博客
04-19 227
Dynamo备份思想 因为我们用的PC机器性能不一，质量参差不齐，可能每天都会有机器挂掉或者重启。我们需要保证在某个机器挂掉或者损坏时，保证工作的正常运行。 我们可能最先想到的就是，给每个节点机器加一台备用的节点。这样，在主节点宕机时，备节点就可以顶上去。但是仔细想一下，这个方案是让人不放心的。因为当一主一备中的某一台机器坏掉，另外一台就成了一个单点运行的节点。这个时候另外一个节点一旦发生错...
35个非主流开源数据库 你知道吗？
Luxika的专栏
09-29 174
[size=medium]几乎每个Web开发人员都有自己喜欢的数据库，或自己最熟悉的数据库，但最常见的无外乎以下几种： 　　MySQL 　　PostgreSQL 　　MSSQL 　　SQLite 　　MS Access 　　或是更简单的XML，文本文件等。这些数据库有优秀的文档，背后有强大的社区支持，大部分流行的CMS都使用了其中之一或多个，它们都易于使用，...
key-value 数据库有哪些
最新发布
08-29
"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值