三级缓存 Volley /Lrucache/DiskLrucache + AndroidStudio导出jar包 + upload to github

最新推荐文章于 2023-09-22 21:12:15 发布
最新推荐文章于 2023-09-22 21:12:15 发布
阅读量1.8k 收藏 3
点赞数 2
分类专栏： Android 文章标签： 三级缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JonsTank2013/article/details/49994615
版权

　　想了半天都没想出来写什么作为第一篇博客比较好，突然发现这次项目的版本控制是github，三级缓存和屏幕适配又是一个跑不掉的话题，就以这些话题开始我的博客之旅吧，同时总结一下在AndroidStudio中如何导出jar包。

([参考郭霖的blog](http://blog.csdn.net/guolin_blog/article/details/28863651))
([参考李晨玮的blog](http://www.cnblogs.com/lichenwei)/)

不管是提升用户体验还是提升APP的流畅度，三级缓存都是必不可少的，在这里就先总结一下三级缓存的使用。

　　加载网络图片时，使用三级缓存可以有效的提高用户体验以及程序的流畅度。
　　三级缓存为以下内容：网络层／内存层／磁盘层
　　缓存的流程如下：
　　１. 网络层下载图片 Volley->imageLoader
　　２. 存入内存层 LruCache
　　３. 存入磁盘层 DiskLruCache
　　而当以上操作均完成以后，此次下载的图片就写入到了手机中，下次运行程序时，就会优先到目录中查找是否存在该图片，如果存在就直接使用，免除了多次加载耗费流量。
首先，在使用之前，包含volley的库以及DiskLrucache,　链接如下
volley
DiskLrucache

　１.　定义MyApplication,　在其中获取到context，避免每次都需要单独获取一次上下文对象。
　在MyApplication中设置有一个静态的TAG,这个TAG是为了获取基础类的名称，以此作为每一个加入RequestQueue的request的标志

package com.mylibs.volley_disklrucache_lrucache.customview;

import android.app.Application;

/**
 * Created by lizhongquan on 15-11-23.
 */
public class MyApplication extends Application {

    /**
     * Application
     */
    public static MyApplication myApplication;

    /**
     * Get Tag to setTag for everyAty
     */
    public static String TAG;

    public static MyApplication getMyApplication() {
        return myApplication;
    }

    @Override
    public void onCreate() {
        super.onCreate();

        myApplication = this;
        TAG = this.getClass().getSimpleName();
    }
}

然后在AndroidManifest文件中声明：　

<application
        android:name=".customview.MyApplication" >
</application>

同样的，为了避免重复编写，将各种工具类进行单独的封装

在Volley中，存在一个RequestQueue就可以了，其他所有的请求都直接放在这个队列中

package com.mylibs.volley_disklrucache_lrucache.utils;

import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.toolbox.Volley;
import com.mylibs.volley_disklrucache_lrucache.customview.MyApplication;

/**
 * Created by lizhongquan on 15-11-23.
 */
public class VolleyRequestQueue {

    /**
     * get RequestQueue
     */
    public static RequestQueue mRequestQueue = Volley.newRequestQueue(MyApplication.getMyApplication());

    /**
     * add request
     */
    public static void addRequest(Request<?> request, Object tag){
        if (null != tag){
            request.setTag(tag);
        }
        mRequestQueue.add(request);
    }

    /**
     * cancel all request
     */
    public static void cancelRequest(Object tag){
        mRequestQueue.cancelAll(tag);
    }
}

　　　　　　　journal内容
对于DiskLruCache,　他是在手机的保存目录中创建一个journal文件，在此文件中有如下内容：
第一行是个固定的字符串“libcore.io.DiskLruCache”，标志着我们使用的是DiskLruCache技术。
第二行是DiskLruCache的版本号，这个值是恒为1。
第三行是应用程序的版本号，我们在open()方法里传入的版本号是什么这里就会显示什么。
第四行是valueCount，这个值也是在open()方法中传入的，通常情况下都为1。
第五行是一个空行。
前五行也被称为journal文件的头。
第六行是以一个DIRTY前缀开始的，后面紧跟着缓存图片的key。通常我们看到DIRTY这个字样都不代表着什么好事情，意味着这是一条脏数据。每当我们调用一次DiskLruCache的edit()方法时，都会向journal文件中写入一条DIRTY记录，表示我们正准备写入一条缓存数据，但不知结果如何。然后调用commit()方法表示写入缓存成功，这时会向journal中写入一条CLEAN记录，意味着这条“脏”数据被“洗干净了”，调用abort()方法表示写入缓存失败，这时会向journal中写入一条REMOVE记录。也就是说，每一行DIRTY的key，后面都应该有一行对应的CLEAN或者REMOVE的记录，否则这条数据就是“脏”的，会被自动删除掉。
第七行的那条记录，除了CLEAN前缀和key之外，后面还有一个152313，这是什么意思呢？其实，DiskLruCache会在每一行CLEAN记录的最后加上该条缓存数据的大小，以字节为单位。152313也就是缓存的图片的字节数了，换算出来大概是148.74K，和缓存图片刚刚好一样大。

以上的一段话包括图片均来自郭霖的博客。

同时，由上可以看出，我们必须对每一个文件名创建一个独立的文件名，比较推荐的一种方式是利用MD5转换。
这个工具类没有好介绍的，直接拿来用就可以了

MD5的工具类：

package com.mylibs.volley_disklrucache_lrucache.utils;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * Created by lizhongquan on 15-11-23.
 */
public class MD5Util {

    /**
     * Encrypt the information by MD5
     */

    public static String md5(String plainText) {
        byte[] secretBytes = null;
        try {
            secretBytes = MessageDigest.getInstance("md5").digest(
                    plainText.getBytes());
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("no md5！");
        }

        /**
         * 16 Band
         */
        String md5code = new BigInteger(1, secretBytes).toString(16);

        /**
         * If number.lenth < 32, add 0 in its front
         */
        for (int i = 0; i < 32 - md5code.length(); i++) {
            md5code = "0" + md5code;
        }
        return md5code;
    }
}

之后，开始准备Volley的ImageLoader的图片缓存类ImageCacheUtil

图片缓存类包含的内容如下：
１．在它的构造方法中设置LruCache的最大缓存，首先获取到可用内存的最大值，使用内存如果超过这个值会引起OutOfMemory异常
２．使用最大可用内存值的1/8作为缓存的大小
３．从LruCache或者DiskLruCache中取出Bitmap, 对于DiskCache来说，首先会利用经MD5转换后的唯一名来进行查找，如果找到，就取出相关的资源
４．保存资源到LruCache或DiskLruCache中。对于DiskLruCache而言，同样是先检测后操作
５．获取磁盘的缓存地址。一般而言，缓存的地址会存放在 /sdcard/Android/data//cache 这个路径下，但是有的手机是没有SD卡的，因此需要进行一个判断。如果存在，使用getExternalCacheDir()方法来获取缓存路径，否则就调用getCacheDir()方法来获取缓存路径。前者获取到的是/sdcard/Android/data//cache ，后者获取到的是 /data/data//cache
６．获取应用程序的版本号。由于DiskLruCache的设置，所以只要我们APP的版本号改变了，缓存路径下存储的数据都会被清楚，因为DiskLruCache认为当应用程序有版本更新的时候，所有数据都应从网上重新获取。

package com.mylibs.volley_disklrucache_lrucache.utils;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Environment;
import android.support.v4.util.LruCache;
import android.util.Log;

import com.android.volley.toolbox.ImageLoader;
import com.mylibs.volley_disklrucache_lrucache.DiskLruCache;
import com.mylibs.volley_disklrucache_lrucache.customview.MyApplication;

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;

/**
 * Created by lizhongquan on 15-11-23.
 */
public class ImageCacheUtil implements ImageLoader.ImageCache {

    // get Tag
    private String TAG = ImageCacheUtil.this.getClass().getSimpleName();

    // LruCache / DiskLruCache
    private static LruCache<String, Bitmap> mLruCache;
    private static DiskLruCache mDiskLruCache;

    // DiskMaxSize
    private static final int DISKMAXSIZE = 10 * 1024 * 1024;

    public ImageCacheUtil() {
        // get 1/8 of memory to Cache
        int maxSize = (int) (Runtime.getRuntime().maxMemory() / 8);

        // Instance LruCaceh对象
        mLruCache = new LruCache<String, Bitmap>(maxSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                return bitmap.getRowBytes() * bitmap.getHeight();
            }
        };

        // get DiskLruCahce
        try {
            mDiskLruCache = DiskLruCache.open(getDiskCacheDir(
                    MyApplication.getMyApplication(), "DiskLruCache"),
                    getAppVersion(MyApplication.getMyApplication()), 1, DISKMAXSIZE);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * getBitmap from LruCache or diskLruCache
     */
    @Override
    public Bitmap getBitmap(String url) {
        if (mLruCache.get(url) != null) {
            // get from LruCache
            Log.i(TAG, "get from LruCache");
            return mLruCache.get(url);
        } else {
            String key = MD5Util.md5(url);
            try {
                if (mDiskLruCache.get(key) != null) {
                    // get from DiskLruCache
                    DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
                    Bitmap bitmap = null;
                    if (snapshot != null) {
                        bitmap = BitmapFactory.decodeStream(snapshot.getInputStream(0));
                        // save into LruCache
                        mLruCache.put(url, bitmap);
                        Log.i(TAG, "get from diskLruCache");
                    }
                    return bitmap;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * save into LruCache or DiskLruCache
     */
    @Override
    public void putBitmap(String url, Bitmap bitmap) {
        // save into LruCache
        mLruCache.put(url, bitmap);

        // get the uniqueName
        String key = MD5Util.md5(url);
        try {
            // Judge if the DiskLruCache exists
            // If not, save into DiskLruCache
            if (mDiskLruCache.get(key) == null) {
                DiskLruCache.Editor editor = mDiskLruCache.edit(key);
                if (editor != null) {
                    OutputStream outputStream = editor.newOutputStream(0);
                    if (bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream)) {
                        editor.commit();
                    } else {
                        editor.abort();
                    }
                }
                mDiskLruCache.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * Judge the SDCard is exits or not and then choose the DiskLruCacheDir
     *
     * @param context context
     * @param uniqueName the name of cache
     * @return The cachePath
     */
    public static File getDiskCacheDir(Context context, String uniqueName) {
        String cachePath;
        if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())
                || !Environment.isExternalStorageRemovable()) {
            cachePath = context.getExternalCacheDir().getPath();
        } else {
            cachePath = context.getCacheDir().getPath();
        }
        return new File(cachePath + File.separator + uniqueName);
    }

    /**
     * getAppVersion
     *
     * @param context
     * @return appVersion
     */
    public int getAppVersion(Context context) {
        try {
            PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
            return info.versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return 1;
    }
}

图片缓存管理类ImageCacheManager
向外部提供一个loadImage的重载方法，一个传入加载图片的宽高，一个默认加载原图，使外部不再需要关注任何关于缓存的操作

package com.mylibs.volley_disklrucache_lrucache.customview;

import android.graphics.Bitmap;
import android.widget.ImageView;

import com.android.volley.VolleyError;
import com.android.volley.toolbox.ImageLoader;
import com.mylibs.volley_disklrucache_lrucache.utils.ImageCacheUtil;
import com.mylibs.volley_disklrucache_lrucache.utils.VolleyRequestQueue;

/**
 * Created by lizhongquan on 15-11-23.
 * ImageCacheManager
 */
public class ImageCacheManager {

    private static String TAG = ImageCacheManager.class.getSimpleName();

    // get ImageCache
    private static ImageLoader.ImageCache mImageCache = new ImageCacheUtil();

    // get ImageLoader
    public static ImageLoader mImageLoader = new ImageLoader(
            VolleyRequestQueue.mRequestQueue, mImageCache);

    /**
     * ImageListener
     *
     * @param imageView    ImageView
     * @param defaultImage defaultImage
     * @param errorImage   errorImage
     * @return　new ImageLoader.ImageListener
     */
    public static ImageLoader.ImageListener getImageListener(final ImageView imageView,
                                                             final Bitmap defaultImage,
                                                             final Bitmap errorImage) {

        return new ImageLoader.ImageListener() {

            @Override
            public void onErrorResponse(VolleyError error) {
                // Error
                if (errorImage != null) {
                    imageView.setImageBitmap(errorImage);
                }
            }

            @Override
            public void onResponse(ImageLoader.ImageContainer response, boolean isImmediate) {
                // Success
                if (response.getBitmap() != null) {
                    imageView.setImageBitmap(response.getBitmap());
                } else if (defaultImage != null) {
                    imageView.setImageBitmap(defaultImage);
                }
            }
        };
    }

    /**
     * Method to LoadImage
     *
     * @param url          URL
     * @param imageView    ImageView
     * @param defaultImage defaultImage
     * @param errorImage   errorImage
     */
    public static void loadImage(String url, ImageView imageView, Bitmap defaultImage,
                                 Bitmap errorImage) {
        mImageLoader.get(url, ImageCacheManager.getImageListener(imageView,
                defaultImage, errorImage), 0, 0);
    }

    /**
     * Method to LoadImage
     *
     * @param url          URL
     * @param imageView    ImageView
     * @param defaultImage defaultImage
     * @param errorImage   errorImage
     * @param maxWidth     maxWidth
     * @param maxHeight    maxHeight
     */
    public static void loadImage(String url, ImageView imageView, Bitmap defaultImage,
                                 Bitmap errorImage, int maxWidth, int maxHeight) {
        mImageLoader.get(url, ImageCacheManager.getImageListener(imageView, defaultImage,
                errorImage), maxWidth, maxHeight);
    }

    /**
     * Method to getBitmapFromRes
     * It's connected to the Method loadImage
     *
     * @param context
     * @param resId
     * @return 
     */
    public static Bitmap getBitmapFromRes(Context context, int resId) {
        Resources res = context.getResources();
        return BitmapFactory.decodeResource(res, resId);
    }
}

MainActivity.java
activty_main.xml中只包含一个TextView 和一个ImageView

package com.mylibs.volley_disklrucache_lrucache.testaty;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;

import com.mylibs.volley_disklrucache_lrucache.R;
import com.mylibs.volley_disklrucache_lrucache.customview.ImageCacheManager;
import com.mylibs.volley_disklrucache_lrucache.customview.MyApplication;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TextView click = (TextView) findViewById(R.id.click);

        final ImageView imageView = (ImageView) findViewById(R.id.imageView);

        click.setText("click");
        click.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String address = "https://www.baidu.com/img/baidu_jgylogo3.gif";
                ImageCacheManager.loadImage(address,
                        imageView,
                        ImageCacheManager.getBitmapFromRes(MyApplication.getMyApplication(), R.mipmap.ic_launcher),
                        ImageCacheManager.getBitmapFromRes(MyApplication.getMyApplication(), R.mipmap.ic_launcher));
            }
        });
    }
}

AndroidStudio导出jar包

相关的代码及测试已经完毕，现在来生成一个jar包，方便以后使用

AndroidStudio下打包生成jar包有两种方式，一种是在build.gradle中编写代码导出，一种是直接在终端中导出。
网上很多推荐在build.gradle中编写导出的，但是就我而言还是比较喜欢直接在终端导出，毕竟终端自己用得多一点

首先， ./gradlew clean build 这一步之前是需要确定已经安装了gradlew的，如果没有安装的话，最好翻墙安装，不然会装很久

之后打开终端，输入：jar cvf libs_volley_lrucache_disklrucache.jar -C /home/lizhongquan/AndroidStudioWorkplace/Volley_DiskLrucache_Lrucache/app/build/intermediates/classes/release .

最后一排的路径可以直接右键/app/build/intermediates/classes/release获得

最后回车，就可以在目录下看到生成的jar包了.

上传到github

由于此次项目的版本控制工具选择了github(git.oschina.net)，　所以在这里也记录一下github的相关操作
此次代码上传的位置：https://github.com/LiZHongquan2013/Libs_VolleyDiskLruCacheLruCache.git

首先，创建一个仓库

git init .
git add .
git commit -m “libs_volley_lrucache_disklrucache”
git remote add origin https://github.com/LiZHongquan2013/Libs_VolleyDiskLruCacheLruCache.git
git push origin master

以前收藏的一个有关git相关操作的博客，挺详细
http://blog.csdn.net/small_rice_/article/details/45095323

第一篇博客到这里就结束了，下一篇为三种屏幕适配

Mr_Zhongquan
关注
专栏目录
DiskLruCache.java
07-20
Android Source 中的 DiskLruCache 类
三级缓存DiskLruCache+LruCache
05-04
本文将详细探讨“三级缓存DiskLruCache+LruCache”在图片加载中的应用，以及Java对象引用的不同类型。 首先，三级缓存机制是针对图片加载的一种优化策略，主要包括内存缓存、文件缓存和网络缓存。这个层次结构的...
Volley(三) 三级缓存策略
hukuhy的博客
11-02 543
在之前的文章中已经介绍过使用Volley的基本方法。总结起来就是需要一个RequestQueue,一个相应的Request，然后在这个RequestQueue中将这个Request添加进去。同时也介绍了图片加载的方法。一共有三个，分别是建立ImageReqest,其次是使用ImageLoader，最后是NetworkImageView方法。我们再来回顾一下ImageRequest方法。在 Ima
结合volley实现图片三级缓存
lh0304123457的博客
12-19 1630
请几天用xutils大致实现了图片加载的本地缓存，后来又看了一下volley框架，volley对图片的处理还是很强大的，有三种方式：imagerequest，imageloader，networkimageview。 imagerequest就是将从服务器读取的数据直接包装成bitmap，通过回调listener获取该对象； imageloader主要是增加了imagecache，增加了图片的
关于Volley图片的三级缓存的基本使用
杨长文的博客
06-16 793
关于Volley图片的三级缓存的基本使用
Volley框架下的三级缓存的使用工具类
LUFANZHENG的专栏
04-12 2256
package com.qianfeng.day01_volley.cache; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.lang.ref.SoftR
Github-volley jar包和源码
03-10
volley是一个优秀的安卓开源网络访问工具 这里包含一个volley代码jar和源码，版本是2015.03.03的1.0.11版本 更多资料可以参见volley的github地址： https://github.com/mcxiaoke/android-volley
Android图片三级缓存策略(网络、本地、内存缓存)
09-02
"Android图片三级缓存策略(网络、本地、内存缓存)"是一种优化图片加载的方法，它旨在减少网络请求，提高用户体验，并防止内存溢出。 一级缓存：内存缓存 内存缓存是最快速的访问方式，因为它直接存储在应用的内存中...
Volley使用，包含get、post请求，获取String/JsonObject/JsonArray数据（android客户端+java服务器端）
04-01
Volley是Google推出的一款高效的Android网络请求库，它旨在简化Android应用中的网络操作，通过减少网络请求的延迟和提高响应速度来提升用户体验。本教程将详细介绍如何使用Volley进行HTTP的GET和POST请求，以及如何...
Android图片三级缓存开发
08-28
Android图片三级缓存就是一种优化图片加载速度和减少内存占用的技术。以下是关于Android图片三级缓存的详细解释： 1. **内存缓存（Memory Cache）**： 内存缓存是最快速的，但同时也是最有限的资源。Android提供了...
磁盘缓存disklrucache.jar第三方库
11-12
DiskLruCache是一个官方认可的管理磁盘缓存的第三方类库。该类可用于在程序中把从网络加载的数据保存到磁盘上作为缓存数据，例如显示图片的瀑布流，需要加载很多图片，可对从网络加载的图片进行缓存，提高程序的可用性。
AndroidStudio利用DiskLruCache和LruCache实现简单的照片墙
11-16
AndroidStudio利用DiskLruCache和LruCache实现简单的照片墙
Android之本地缓存——LruCache（内存缓存）与DiskLruCache（硬盘缓存）统一框架
07-02
http://blog.csdn.net/yangzhaomuma/article/details/51810418 该框架或者说库，主要是用于本地的图片缓存处理。 数据的存入 当你取到图片的元数据，会将数据存入硬盘缓存以及内存缓存中。 数据的获取 取数据的时候，先从内存缓存中取； 如果没有取到，则从硬盘缓存中取（此时如果硬盘缓存有数据，硬盘缓存会重新将数据写入内存缓存中）； 如果硬盘缓存中没有取到，则从网上重新获取元数据；
Android-DiskLruCache.java类最新版
09-03
DiskLruCache是Java实现基于LRU的磁盘缓存，APP中的内容和图片在从网络上获取到之后都会存入到本地缓存中，因此即使手机在没有网络的情况下依然能够加载出以前浏览过的图片和内容
Android中Rxjava实现三级缓存的两种方式
01-04
本文正如标题所说的用rxjava实现数据的三级缓存分别为内存，磁盘，网络，刚好最近在看Android源码设计模式解析与实战（受里面的ImageLoader的设计启发）。 我把代码放到了我的hot项目中，github地址 源码下载地址：Rxjava_jb51.rar 1.使用concat()和first()的操作符。 2.使用BehaviorSubject。 先说BehaviorSubject的实现方法，废话不多说直接上代码， /** * Created by wukewei on 16/6/20. */ public class BehaviorSubjectFragment
如何正确的导入DiskLruCache
ButtonXin的博客
08-14 1881
DiskLruCache就是一个java类 只有需要复制到自己的项目中就可以了 下载地址（科学上网）：android.googlesource.com/platform/libcore/+/jb-mr2-release/luni/src/main/java/libcore/io/DiskLruCache.java 或者下面我贴出来 将DiskLruCache.java 下载后 ，导入自己的项目需要注
android磁盘缓存DiskLruCache使用
乐活青年的博客
08-29 443
private static final long DISK_CACHE_SIZE = 50*1024*1024;//磁盘缓存大小为50M File diskCacheDir = getDiskCacheDir("bitmap");//此方法需要通过22处理 if(!diskCacheDir.exists()){   diskCacheDir.mkdirs(); } //创建对象 D...
Android中的缓存策略：LruCache和DiskLruCache
最新发布
Tai_Monster的博客
09-22 938
本篇文章主要是介绍Android中内置的两个缓存类的原理。所谓缓存，就是将获取的数据保存下来以便下次继续使用，这种技术尤其在网络请求和图片加载中有用，可以显著地提升App的性能表现。Android中也内置了两个缓存类，分别是和。
Android图片缓存机制详解：三级缓存实现
"Android中图片的三级缓存机制" 在Android应用开发中，高效地加载和管理图片是一项重要的任务。为了优化用户体验，Android引入了图片的三级缓存机制，这是一个智能的图片加载策略，旨在减少网络请求，提高加载速度...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值