[zip]android下实现直接读取zip中的文件

最新推荐文章于 2019-04-19 22:53:29 发布
最新推荐文章于 2019-04-19 22:53:29 发布
阅读量5.5k 收藏 5
点赞数
分类专栏： zip android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/victoryckl/article/details/8567575
版权
android 同时被 2 个专栏收录
298 篇文章 0 订阅
订阅专栏
zip
1 篇文章 0 订阅
订阅专栏

     不用解压，直接读取zip中指定的文件，例如文件/sdcard/a.zip中有文件z.txt，读取步骤如下：

	int zfd = zip_open("/sdcard/a.zip/z.txt");
	if (ZIP_IS_VALID(zfd)) {
		zip_seek(zfd, 5, SEEK_SET);
		zip_read(zfd, buf, 10);
		zip_close(zfd);
	}

1.依赖于android framework中的ZipFileRO.h，要求在android系统源码环境中编译；

2.目前只支持以“存储“格式压缩的zip文件；

3.主要接口：

int zip_open(const char* path);
int zip_close(int handle);
int zip_read(int handle, void *buf, int count);
int zip_seek(int fd, int offset, int whence);
int zip_stat(const char *file_name, struct stat *buf);

zip_wrapper.h 

/*
 * read a file in zip as normal file.
 * only support kCompressStored method
 * 
 * dependent on android ZipFileRO.h
 * build in AOSP
 *
 * zip_open 
 * zip_close
 * zip_read
 * zip_seek
 * zip_stat
 */

#ifndef _ZIP_WRAPPER_H_
#define _ZIP_WRAPPER_H_

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>

#include <android/log.h>


#ifdef __cplusplus
extern "C" {
#endif

#define LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG,__VA_ARGS__)
#define LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define LOGW(...)  __android_log_print(ANDROID_LOG_WARN,LOG_TAG,__VA_ARGS__)
#define LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
#define LOGF(...)  __android_log_print(ANDROID_LOG_FATAL,LOG_TAG,__VA_ARGS__)

#define ZIP_IS_VALID(f) ((f) != 0)

int zip_open(const char* path);
int zip_close(int handle);
int zip_read(int handle, void *buf, int count);
int zip_seek(int fd, int offset, int whence);
int zip_stat(const char *file_name, struct stat *buf);

#ifdef __cplusplus
}
#endif

#endif //#ifndef _ZIP_WRAPPER_H_

zip_wrapper.cpp 

#define LOG_TAG "zip_wrapper"

#include <utils/ZipFileRO.h>
#include "zip_wrapper.h"

using namespace android;

extern "C" {

#define ZIP_FLAG ".zip/"
#define ZIP_FLAG_LEN strlen(ZIP_FLAG)

static int is_file(const char* path)
{
	int ok = 0;
	struct stat buf;
	
	int ret = stat(path, &buf);
	if (ret == 0) {
		if (S_ISREG(buf.st_mode)) {
			ok = 1;//is file
		} else {
			//LOGI("%s is not a file !", path);
		}
	} else {
		LOGI("%s is not exist ! ret = %d", path, ret);
	}
	
	return ok;
}

static int is_dir(const char* path)
{
	int ok = 0;
	struct stat buf;
	
	int ret = stat(path, &buf);
	if (ret == 0) {
		if (S_ISDIR(buf.st_mode)) {
			ok = 1;//is dir
		} else {
			//LOGI("%s is not a dir !", path);
		}
	} else {
		LOGI("%s is not exist !", path);
	}
	
	return ok;
}

static int get_zip_path(const char* path, char* zippath)
{
    int ok = 0;
    const char* p = NULL;

    p = strstr(path, ZIP_FLAG); 
    if (p && (p + ZIP_FLAG_LEN != path + strlen(path))) {
        if (zippath) {
            strncpy(zippath, path, p + ZIP_FLAG_LEN - 1 - path);
            LOGI("zip path: %s", zippath);
        } // else, just judge the path is ok
        ok = 1;
    }

    return ok;
}

static int get_path_in_zip(const char* path, char* pathinzip)
{
    int ok = 0;
    const char* p = NULL;
	
    p = strstr(path, ZIP_FLAG); 
    if (p && (p + ZIP_FLAG_LEN != path + strlen(path))) {
        if (pathinzip) {
            strcpy(pathinzip, p + ZIP_FLAG_LEN);
            //LOGI("path in zip: %s", pathinzip);
        } // else, just judge the path is ok
        ok = 1;
    }

    return ok;
}

// whether or not the file is in zip 
// /xxx/a.zip/b.txt  return true if a.zip is a file, else false
// /xxx/a.zip/       return false
// /xxx/a.zip        return false
// /xxx/a.txt        return false
//
int is_in_zip(const char* path)
{
    int iszip = 0;
    struct stat buf;
	char zippath[PATH_MAX] = {0};

	if (path == NULL) {
		LOGE("is_in_zip() path is null !");
		return iszip;
	}
	
    int ret = stat(path, &buf);
	//LOGI("PATH_MAX = %d", PATH_MAX);
	LOGI("path: %s", path);
    if (ret < 0) { // failed, maybe /xxx/a.zip/b.txt or no exist
        if (get_zip_path(path, zippath)) {
			if (is_file(zippath)) {
				LOGI("%s is in zip: %s", path, zippath);
				iszip = 1; // OK
			} else {
				LOGI("%s is not a zip", zippath);
			}
        } else {
			LOGI("%s is not exist!", path);
		}
    } else {
		if (S_ISDIR(buf.st_mode)) {
			LOGI("%s is a dir", path);
		} else if (S_ISREG(buf.st_mode)) {
			LOGI("%s is a file", path);
		} else {
			LOGI("%s not a file or dir", path);
		}
    }
    return iszip;
}

/******************************************************************/

typedef struct _zip_priv {
	ZipFileRO * zip;
	ZipEntryRO entry;
	FileMap * map;
	off_t offset;
}zip_priv;

static zip_priv * _zip_priv_open(const char * path)
{
	char zippath[PATH_MAX] = {0};
	char filepath[256] = {0};
	get_zip_path(path, zippath);
	get_path_in_zip(path, filepath);

	int fd = 0;
	zip_priv * zp = NULL;
	
	ZipFileRO * zip = new ZipFileRO();
	ZipEntryRO entry = NULL;
	FileMap* map = NULL;
	
	do
	{
		if (zip->open(zippath) != NO_ERROR) {
			LOGE("zip->open(%s) failed!", zippath);
			break;
		}

		entry = zip->findEntryByName(filepath);
		if (entry == 0) {
			LOGE("zip->findEntryByName(%s) failed!", filepath);
			break;
		}
		
		int method = 0;
		if (!zip->getEntryInfo(entry, &method, 0, 0, 0, 0, 0)) {
			LOGE("zip->getEntryInfo() failed!");
			break;
		}
		// only support stored method
		if (method != ZipFileRO::kCompressStored) {
			LOGE("error: not support, method = %d !\n"
			"only support kCompressStored", method);
			break;
		}
		
		map = zip->createEntryFileMap(entry);
		if (map == 0) {
			LOGE("zip->createEntryFileMap(%p) failed!", entry);
			break;
		}
		
		zp = (zip_priv *)malloc(sizeof(zip_priv));
		if (zp == NULL) {
			LOGE("malloc(sizeof(zip_priv)) failed !");
			break;
		}
		
		memset(zp, 0, sizeof(zip_priv));		
		zp->zip    = zip;
		zp->entry  = entry;
		zp->map    = map;
		zp->offset = 0;
		
		fd = (int)zp; //ok
	}while(0);
	
	if (fd == 0) {
		if (map) map->release();
		if (zip) delete zip;
		if (zp) free(zp);
		LOGI("_zip_open(%s) failed !", path);
	} else {
		LOGI("_zip_open(%s) ok !", path);
	}
	
	return zp;
}

static int _zip_open(const char * path)
{
	return (int)_zip_priv_open(path);
}

static int _zip_close(int handle)
{
	int ret = -1;
	zip_priv * zp = (zip_priv*)handle;
	if (zp) {
		zp->map->release();
		delete zp->zip;
		free(zp);
		ret = 0;
	}	
    return ret;
}

static ssize_t _zip_read(int handle, void *buf, size_t count)
{
	int ret = -1;
	zip_priv * zp = (zip_priv*)handle;
	if (zp) {
		size_t max = zp->map->getDataLength() - zp->offset;
		max = max < count ? max : count;
		if (max > 0) {
			memcpy(buf, ((char *)zp->map->getDataPtr()) + zp->offset, max);
			zp->offset += max;
		}
		ret = max;
	}
    return ret;
}

static off_t _zip_seek(int handle, off_t offset, int whence)
{
	int ret = -1;
	zip_priv * zp = (zip_priv*)handle;
	off_t _offset, datalen;
	
	if (zp) {
		_offset = zp->offset;
		datalen = zp->map->getDataLength();
		switch(whence) {
			case SEEK_SET:
				_offset = offset;
				break;
			case SEEK_CUR:
				_offset += offset;
				break;
			case SEEK_END:
				_offset = datalen + offset;
				break;
			default:
				LOGE("_zip_seek not support whence: %d", whence);
				break;
		}
		if (_offset != zp->offset) {
			_offset = _offset >= 0 ? _offset : 0;
			zp->offset = _offset <= datalen ? _offset : datalen;	
		}
		ret = zp->offset;
	}

    return ret;
}

/*
buf->st_size
buf->st_mode & S_IFREG
buf->st_mode & S_IFDIR
buf->st_mtime
*/
static int _zip_stat(const char *file_name, struct stat *buf)
{
	int ret = -1;
	zip_priv * zp = _zip_priv_open(file_name);
	do 
	{
		if (zp == NULL) {
			break;
		}
		
		memset(buf, 0, sizeof(struct stat));
		
		size_t uncompLen = 0;
		if (!zp->zip->getEntryInfo(zp->entry, 0, &uncompLen, 0, 0, 0, 0)) {
			LOGE("zp->zip->getEntryInfo() failed !");
			break;
		}
		LOGI("uncompLen = %d", uncompLen);
		buf->st_size = uncompLen;
		
		char name[256] = {0};
		if (zp->zip->getEntryFileName(zp->entry, name, sizeof(name)) == -1) {
			LOGE("zp->zip->getEntryFileName() failed !");
			break;
		}
		if (name[strlen(name) - 1] == '/') {
			buf->st_mode = S_IFDIR;
			LOGI("%s is a dir", name);
		} else {
			buf->st_mode = S_IFREG;
			LOGI("%s is a file", name);
		}
		
		buf->st_mtime = 0;
		ret = 0;
	}while(0);
	
	if (zp) {
		_zip_close((int)zp);
	}
	
    return ret;
}

/******************************************************************/
typedef struct _fs_operator {
	int     (*close)(int handle);
	ssize_t (*read) (int handle, void *buf, size_t count);
	off_t   (*seek) (int handle, off_t offset, int whence);
} fs_operator;

typedef struct _zip_info {
	const fs_operator * opt;
	int fd;
} zip_info;

static const fs_operator s_operator[] = 
{
	{
		close, 
		read, 
		lseek, 
	},
	{
		_zip_close, 
		_zip_read, 
		_zip_seek, 
	},
};

/******************************************************************/    
// api

int zip_open(const char* path)
{
	int zfd = 0;
	zip_info * pz = NULL;
	
    if (path == NULL) {
        LOGE("zip_open: path is null");
        return -1;
    }

    do 
	{
		pz = (zip_info *) malloc(sizeof(zip_info));
		if (pz == NULL) {
			LOGE("malloc(sizeof(zip_info)) failed !");
			break;
		}
		memset(pz, 0, sizeof(zip_info));
		
		int fd = 0;
		if (is_in_zip(path)) {
			fd = _zip_open(path);
			if (!fd) {
				break;
			}
			pz->opt = &s_operator[1];
		} else {
			fd = open(path, O_RDONLY);
			if (fd < 0) {
				LOGE("open(%s) failed!", path);
				break;
			}
			pz->opt = &s_operator[0];
		}
		pz->fd = fd;
		zfd = (int)pz;
	}while(0);

	if (!ZIP_IS_VALID(zfd)) {
		if (pz) free(pz);
	}
	
    return zfd;
}

int zip_close(int handle)
{
	int ret = -1;
	zip_info * pz = (zip_info *)handle;
	if (pz) {
		ret = pz->opt->close(pz->fd);
		free(pz);
	}
    return ret;
}

int zip_read(int handle, void *buf, int count)
{
	int ret = -1;
	zip_info * pz = (zip_info *)handle;
	if (pz) {
		ret = pz->opt->read(pz->fd, buf, count);
	}
    return ret;
}

int zip_seek(int handle, int offset, int whence)
{
	int ret = -1;
	zip_info * pz = (zip_info *)handle;
	if (pz) {
		ret = pz->opt->seek(pz->fd, offset, whence);
	}
    return ret;
}

int zip_stat(const char *file_name, struct stat *buf)
{
	int ret = -1;
	if(file_name && buf) {
		if (is_in_zip(file_name)) {
			ret = _zip_stat(file_name, buf);
		} else {
			ret = stat(file_name, buf);
		}
	} else {
		
	}
    return ret;
}

}//extern "C" {

zip_main.cpp 

#define LOG_TAG "zip_wrapper"

#include <utils/String8.h>
#include <utils/ZipFileRO.h>

#include "zip_wrapper.h"

using namespace android;

extern "C" {
	int is_in_zip(const char* path);
}

// ---------------------------------------------------------------------------
int testReadEntry(int argc, char** argv)
{
    ZipFileRO mZip;
    
    char path[256] = "/sdcard/zip/demo.zip";
    
    if (argc >= 2) {
        strcpy(path, argv[1]);
    }

    LOGI("path: %s\n", path);

    mZip.open(path); 
    size_t numEntries = mZip.getNumEntries();
    LOGI("numEntries: %d\n", numEntries);
    if ((int)numEntries < 0){
        return 0;
    }

    int method = 0;
    size_t uncompLen = 0;
    size_t compLen = 0;
    off64_t offset = 0;
    long modWhen = 0;
    long crc32 = 0;

    char name[256] = {0};
    for (size_t i=0 ; i<numEntries ; i++) {
        ZipEntryRO entry = mZip.findEntryByIndex(i);
        if (mZip.getEntryFileName(entry, name, sizeof(name)) == 0) {
            if (mZip.getEntryInfo(entry, &method, &uncompLen, 
                        &compLen, &offset, &modWhen, &crc32)) {
                LOGI("name:[%d] %s\n", i, name);
                LOGI("method: %d\n", method);
                LOGI("uncompLen: %d,\tcompLen: %d\n", uncompLen, compLen);
                LOGI("offset: %lld,\tcrc32: 0x%lx\n", offset, crc32);
            }
        }
    }

    return 0;
}


int testIsInZip(int argc, char** argv)
{
	if (argc < 2) {
		LOGE("parameter is error! :%s filepath", argv[0]);
		return -1;
	}
	return is_in_zip(argv[1]);
}

int testRead(int argc, char** argv)
{
	int zfd = 0;
	char buf[100] = {0};
	
	if (argc < 2) {
		LOGE("parameter is error! :%s filepath", argv[0]);
		return -1;
	}
	
	zfd = zip_open(argv[1]);
	LOGI("zfd = 0x%x", zfd);
	if (ZIP_IS_VALID(zfd)) {
		zip_read(zfd, buf, 10);
		LOGI("read: %s", buf);
		
		memset(buf, 0, sizeof(buf));
		zip_seek(zfd, 5, SEEK_SET);
		zip_read(zfd, buf, 10);
		LOGI("read: %s", buf);
		
		zip_close(zfd);
	}
	return 0;
}

int testStat(int argc, char** argv)
{
	struct stat buf;
	
	if (argc < 2) {
		LOGE("parameter is error! :%s filepath", argv[0]);
		return -1;
	}
	
	zip_stat(argv[1], &buf);

	return 0;
}

int main(int argc, char** argv)
{
    //testReadEntry(argc, argv);
	//testIsInZip(argc, argv);
	//testRead(argc, argv);
	testStat(argc, argv);
    return 0;
}

Android.mk 

LOCAL_PATH:= $(call my-dir)

#################################
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
	zip_wrapper.cpp

LOCAL_CFLAGS := 
LOCAL_SHARED_LIBRARIES := libutils 

LOCAL_C_INCLUDES := .
LOCAL_MODULE_TAGS:= optional
LOCAL_MODULE:= libreadzip
include $(BUILD_STATIC_LIBRARY)

#################################
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
	zip_main.cpp 
	
LOCAL_CFLAGS := 
LOCAL_STATIC_LIBRARIES := libreadzip
LOCAL_SHARED_LIBRARIES := libutils 

LOCAL_C_INCLUDES := .
LOCAL_MODULE_TAGS:= optional
LOCAL_MODULE:= readzip
include $(BUILD_EXECUTABLE)




victoryckl
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SDCardFormatter.zip
01-15
SDCardFormatter安装包
（原创）安卓读取压缩包里某个文件的内容
Android_xiong_st的博客
08-29 1756
在开发中，有时候需要去读取文件，但是如果这个文件在压缩包里怎么办呢？ 其实安卓也提供了对应的处理方法 今天就大概介绍一下 主要用到的是ZipFile这个类 具体代码如下 ZipFile zip = new ZipFile(zipFilepath); zipFilepath就是你要读取的压缩包的所在路径 Enumeration<ZipEntry> entries = ...
Android： 不解压直接读取压缩包中的文件
dc3120的专栏
04-19 1735
不解压直接读取压缩包中的文件 https://www.cnblogs.com/jeffen/p/6931199.html 最近做的一个Android项目中，需要将一个有20W份html文件的压缩包下载到本地，解压后在本地浏览；在解压的时候尝试了很多方法都无法完成解压（文件数量太大，要么解压超慢要么就内存溢出程序崩溃），后来放弃解压，直接从压缩包中读取文件，下面将方法整理如下 通...
Android重量级开发之--提高android启动速度研究
yuyin86的专栏
01-12 963
Android重量级开发之--提高android启动速度研究                                    www.eoeandroid.com首发，作者：Tigertang2@gmail.com      大家都知道启动速度慢是智能操作系统的一个通病，Android也不例外，启动速度大概在1分钟左右，虽然
Android -- SDcard文件读取和保存
weixin_33775572的博客
05-16 125
背景                                                                                            一些东西可以存在自己定义的文件里面，这个文件可以在手机中，可以在SD卡中，在这里就主要介绍一下在SD卡中的存储和读取吧~ 代码                                        ...
Android 不解压直接读取zip包的方法
08-28
Android 不解压直接读取zip包的方法 Android 不解压直接读取zip包是一种高效的资源读取方法，能够直接从zip包中读取资源，而不需要将其解压缩。这种方法在 Android 开发中非常有用，特别是在需要读取服务器下载下来...
Android实现zip文件压缩及解压缩的方法
09-03
本篇文章将详细讲解如何在Android环境下实现zip文件的压缩和解压缩。 首先，我们来看`DirTraversal.java`，这是一个用于遍历文件目录的类。它提供了两个方法： 1. `listLinkedFiles(String strPath)`：此方法使用...
Android中实现下载和解压zip文件功能代码分享
09-03
以下是一份在Android中实现下载和解压ZIP文件功能的代码示例。 首先，我们需要创建一个异步任务`AsyncTask`来处理下载过程。`DownLoaderTask`类继承自`AsyncTask, Integer, Long>`，它接受三个泛型参数，分别代表无...
Android实现下载zip压缩文件并解压的方法（附源码）
08-31
这个例子展示了如何在Android中实现下载zip文件并解压到指定目录。整个过程分为两步：首先通过`AsyncTask`下载文件，然后在下载完成后调用解压缩方法。注意，为了保持良好的用户体验，所有的网络操作和IO操作都应在...
Android实现文件或文件夹压缩成.zip格式压缩包
08-27
那么如何在Android中实现文件或文件夹的压缩成.zip格式压缩包呢？ 答案是使用Java的ZipOutputStream和ZipEntry类，通过这两个类，我们可以轻松地实现文件或文件夹的压缩和解压缩操作。 首先，我们需要创建一个...
httpReadJson_Android直接加载网络json文件读取数据.zip
06-11
本教程将详细介绍如何在Android应用中直接加载并解析来自网络的JSON文件。 首先，我们需要了解HTTP协议。HTTP（超文本传输协议）是互联网上应用最广泛的一种网络协议，用于从Web服务器传输超媒体信息到客户端。在...
Android zip文件下载和解压实例
09-04
首先，创建`ZipInputStream`，从下载的文件中读取zip数据。然后，遍历`ZipEntry`，为每个条目创建对应的文件或目录，并使用`ZipInputStream`读取条目的内容，写入到相应的文件中。注意，处理每个条目时需要考虑文件...
Android中实现保存和读取文本文件到内部存储器(实现简易的记事本为例)示例代码.zip
12-02
Android中实现保存和读取文本文件到内部存储器(实现简易的记事本为例)示例代码.zip Android中实现保存和读取文本文件到内部存储器(实现简易的记事本为例)示例代码.zip Android中实现保存和读取文本文件到内部存储器...
java android zip解压缩（解决压缩中文乱码问题)
07-11
在Android开发中，处理压缩文件是一项常见的任务，尤其是在下载、更新或者备份数据时。然而，当压缩文件包含中文字符时，解压缩过程中可能会遇到乱码问题。这是因为编码格式不匹配或者处理方式不当导致的。本篇文章...
仿墨迹天气在Android App中实现自定义zip皮肤更换
01-05
墨迹天气下载的皮肤就是一个zip格式的压缩包，在应用的时候把皮肤资源释放到墨迹天气应用的目录下，更换皮肤时新的皮肤资源会替换掉老的皮肤资源每次加载的时候就是从手机硬盘上读取图片，这些图片资源的命名和程序...
安装APK时SO库的选择策略
weixin_34315189的博客
10-31 234
此文已由作者尹彬彬授权网易云社区发布。欢迎访问网易云社区，了解更多网易技术产品运营经验。0X0 前言在Android系统中，当我们安装apk文件的时候，lib目录下的so文件会被解压到app的原生库目录，一般来说是放到/data/data/&lt;package-name&gt;/lib目录下，而根据系统和CPU架构的不同，其拷贝策略也是不一样的，在我们测试过程中发现不正确地配置了so文件,比如某...
android 解压缩zip文件并取出所有文件
Schrodinger' Code
08-25 1510
1.选择某个zip文件后，在zip文件的目录创建一个与zip文件同名的文件夹，并在该文件夹下解压缩 因为在windows和在mac下压缩所采用的编码不一样，有可能导致中文名解压缩出来出现乱码。解压缩windows zip包需要设置编码为GBK，解压缩mac zip包需要设置编码为UTF-8。一开始时默认解压缩编码为GBK，若zip包为mac压缩，则转换成UTF-8重新解压缩。能解决大部分的中文名
android 从文件制定位置读取数据
谢岩的博客
01-11 4688
今天，简单讲讲android 如何从制定的位置读取文件。 之前，我写了使用FileInputStream使用read（byte[] b）读取文件的博客，每次调用read()时，FileInputStream会自动向后移位读取的数据长度。那如何我想读取之前已经的读取的数据那应该怎么办呢？在网上搜索了资料，最终解决了问题。 从文件指定位置开始读取文件流 文件任意位置读取 一般有
Android 不解压直接读取zip包
mackkill的专栏
04-20 6642
之前项目中遇到个需求，总监让我们把从服务器下载下来的资源不解压直接读取里面的资源，这样的话就省去了一个个校验资源是否正确的步骤，听着貌似有点道理。。。废话不多说直接上代码。 目前我所试验过的可以读取的资源有文本、图片、xml文件。 文本： zip包目录结构：res/txt/data.json 文件sd卡路径：android.os.Environment.getExternalStorage...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值