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

最新推荐文章于 2017-02-24 13:11:41 发布
最新推荐文章于 2017-02-24 13:11:41 发布
阅读量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
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
DiskLruCache.java
07-20
Android Source 中的 DiskLruCache 类
Volley(三) 三级缓存策略
hukuhy的博客
11-02 519
在之前的文章中已经介绍过使用Volley的基本方法。总结起来就是需要一个RequestQueue,一个相应的Request，然后在这个RequestQueue中将这个Request添加进去。同时也介绍了图片加载的方法。一共有三个，分别是建立ImageReqest,其次是使用ImageLoader，最后是NetworkImageView方法。我们再来回顾一下ImageRequest方法。在 Ima
磁盘缓存disklrucache.jar第三方库
11-12
DiskLruCache是一个官方认可的管理磁盘缓存的第三方类库。该类可用于在程序中把从网络加载的数据保存到磁盘上作为缓存数据，例如显示图片的瀑布流，需要加载很多图片，可对从网络加载的图片进行缓存，提高程序的可用性。
Android DiskLruCache完全解析，硬盘缓存的最佳方案
境界
03-05 889
test
AndroidStudio利用DiskLruCache和LruCache实现简单的照片墙
11-16
AndroidStudio利用DiskLruCache和LruCache实现简单的照片墙
Github-volley jar包和源码
03-10
volley是一个优秀的安卓开源网络访问工具 这里包含一个volley代码jar和源码，版本是2015.03.03的1.0.11版本 更多资料可以参见volley的github地址： https://github.com/mcxiaoke/android-volley
AndroidVolley源码jar包
08-05
安卓Android Volley jar包。并且编译成utf-8
Github-volley 最新jar包和源代码 2015.07.28
09-06
Volley是一个优秀的安卓开源网络访问工具，这里包含了volley jar包和源码，版本是2015.07.28的1.0.18版本。更多资料可以参见volley的github地址： https://github.com/mcxiaoke/android-volley 1.0.18 2015.07....
Android Volley Jar网络处理包.zip
09-01
Volley使用，包含get、post请求，获取String/JsonObject/JsonArray数据（android客户端+java服务器端）
04-01
andriod Volley的HTTP网络通信，包含get、post请求，获取String/JsonObject/JsonArray数据（android客户端+java服务器端）
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
Android之本地缓存——LruCache（内存缓存）与DiskLruCache（硬盘缓存）统一框架
07-02
http://blog.csdn.net/yangzhaomuma/article/details/51810418 该框架或者说库，主要是用于本地的图片缓存处理。 数据的存入 当你取到图片的元数据，会将数据存入硬盘缓存以及内存缓存中。 数据的获取 取数据的时候，先从内存缓存中取； 如果没有取到，则从硬盘缓存中取（此时如果硬盘缓存有数据，硬盘缓存会重新将数据写入内存缓存中）； 如果硬盘缓存中没有取到，则从网上重新获取元数据；
Android-DiskLruCache.java类最新版
09-03
DiskLruCache是Java实现基于LRU的磁盘缓存，APP中的内容和图片在从网络上获取到之后都会存入到本地缓存中，因此即使手机在没有网络的情况下依然能够加载出以前浏览过的图片和内容
Rxjava原理探索：切换线程，变换
热门推荐
Hello! Mr.L
03-25 1万+
在之前的几篇博客中，我编写了一篇有关Rxjava学习笔记的，还有一个是RxJava使用示例（一）： 实现Rxbus代替eventbus（这篇博文其实还不算完善，因为没有对被观察者发出的时间进行一个筛选，一次发送所有订阅者都会收到，这样不太好，可以再新加一个筛选器，等以后有空或者是遇到的时候再来改一改，现在不急）。之前在写那边Rxjava学习笔记的时候，就突出了一点是只涉及使用，不涉及原理，现在就对R
RxJava使用示例： 实现Rxbus代替eventbus
Hello! Mr.L
01-24 1万+
之前学习了Rxjava（RxJava学习笔记），但是一直找不到使用它的地方。最近做项目的时候遇到需要使用eventbus的时候，突然想起来Rxjava的一个拓展面就是Rxbus，果断用来试试什么是EventbusEventBus定义：是一个发布 / 订阅的事件总线。 这么说应该包含4个成分：发布者，订阅者，事件，总线。 那么这四者的关系是什么呢？ 很明显：订阅者订阅事件到总线，发送者发布事件。
Android推送（长连接）探索
Hello! Mr.L
03-23 7034
android推送的方式存在几种，包括轮询，长连接等方式，由于其他的方式用户体验并不是特别好（耗电或者是消耗资源），所以现在大部分的推送都使用的是socket长连接的方式。
ViewPager 取消预加载
Hello! Mr.L
12-08 5981
ViewPager在设计的时候有一个预加载的机制，也就是如果你处于当前这个page界面时,会预先加载下一个page。但是有的时候设计到网络请求，就需要取消掉这个预加载。
自定义控件（一） EditText自定义
Hello! Mr.L
01-12 3337
自定义控件分三种： 1. 自绘控件 2. 组合控件 3. 继承控件代码已上传到 github 以后的自定义控件就都放这个仓库需求这里由于项目的需要实现一个自定义EditText,主要实现的为两点，一个是工具图标toolIcon，例如点击清除EditText内容。一个为EditText左边的提示图标hintIcon, 例如输入账号密码时前面的图标。为了让这个控件的拓展性更高，设置了两个点击事件
Android重构记录及其模块化
Hello! Mr.L
02-24 2528
本文仅为个人观点，不完全符合模块化的标准定义及其拓展。思路类似，仅此而已。不可当做模块化的标准理解。 如果各位对于本博客中提到的任何思路或者架构有任何看法，欢迎讨论。以下仅是这3天的个人考虑，基于个人能力及视野的限制，很有可能不完善，欢迎批评指正，共同进步。 转载请注明出处：http://blog.csdn.net/jonstank2013?viewmode=contents
android+studio制作新闻
最新发布
12-20
Android Studio是一款专门用于开发Android应用程序的集成开发环境（IDE）。使用Android Studio可以方便地制作新闻类APP。下面是一个简单的示例： 1. 创建一个新的Android项目： - 打开Android Studio并点击"Start ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值