Amazon S3 功能介绍

最新推荐文章于 2025-03-18 12:38:08 发布
最新推荐文章于 2025-03-18 12:38:08 发布
阅读量416 收藏 2
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/xxj-bigshow/p/9146753.html
本文介绍Amazon Simple Storage Service (S3) 的基本概念及其Java SDK的使用方法，包括如何配置访问凭证、创建和管理存储桶、上传下载文件等。

引自：https://blog.youkuaiyun.com/tomcat_2014/article/details/50582547

一 .Amazon S3介绍

Amazon Simple Storage Service (Amazon S3) 是一种对象存储，它具有简单的 Web 服务接口，可用于在 Web 上的任何位置存储和检索任意数量的数据。它能够提供 99.999999999% 的持久性，并且可以在全球大规模传递数万亿对象。

客户使用 S3 作为云原生应用程序的主要存储；作为分析的批量存储库或“数据湖”；作为备份和恢复以及灾难恢复的目标；并将其与无服务器计算配合使用。

使用 Amazon 的云数据迁移选项，客户可以轻松地将大量数据移入或移出 Amazon S3。数据在存储到 S3 中之后，会自动采用成本更低、存储期限更长的云存储类 (如 S3 Standard – Infrequent Access 和 Amazon Glacier) 进行存档。

二.Java S3 Example
准备工作：
1.导入依赖包
    <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>aws-java-sdk</artifactId>
        <version>1.9.2</version>
    </dependency>
2.在s3服务中创建用户，获取用户的Access key和Secret Access Key，使用这个作为凭证连接s3
3.在s3服务中配置AWSConnector和AmazonS3FullAccess的连接权限。可以通过这个配置，在访问的时候进行authenticate验证。
s3 api简单操作：
1.创建凭证
    AWSCredentials credentials = new BasicAWSCredentials("YourAccessKeyID", "YourSecretAccessKey");
2.创建S3 Client
    AmazonS3 s3client = new AmazonS3Client(credentials);
3.创建Bucket
    String bucketName = "javatutorial-net-example-bucket";
    s3client.createBucket(bucketName);
4.获取s3 Bucket的list
    for (Bucket bucket : s3client.listBuckets()) {
        System.out.println(" - " + bucket.getName());
    }
5.在s3 Bucket中创建文件
    public static void createFolder(String bucketName, String folderName, AmazonS3 client) {
        // create meta-data for your folder and set content-length to 0
        ObjectMetadata metadata = new ObjectMetadata();
        metadata.setContentLength(0);
        // create empty content
        InputStream emptyContent = new ByteArrayInputStream(new byte[0]);
        // create a PutObjectRequest passing the folder name suffixed by /
        PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName,
                    folderName + SUFFIX, emptyContent, metadata);
        // send request to S3 to create folder
        client.putObject(putObjectRequest);
    }
6.上传文件
    String fileName = folderName + SUFFIX + "testvideo.mp4";
    s3client.putObject(new PutObjectRequest(bucketName, fileName, 
            new File("C:\\Users\\user\\Desktop\\testvideo.mp4")));
7.删除Bucket
    s3client.deleteBucket(bucketName);
8.删除文件
    s3client.deleteObject(bucketName, fileName);

 

package com.hx.lubo.web.util;  
  
/** 
 * Created by Administrator on 2016/1/20. 
 */  
  
  
import com.amazonaws.ClientConfiguration;  
import com.amazonaws.Protocol;  
import com.amazonaws.auth.AWSCredentials;  
import com.amazonaws.auth.BasicAWSCredentials;  
import com.amazonaws.services.s3.AmazonS3;  
import com.amazonaws.services.s3.AmazonS3Client;  
import com.amazonaws.services.s3.model.*;  
import com.amazonaws.util.StringUtils;  
import com.hx.lubo.dto.StorageObjectVo;  
import org.springframework.beans.factory.annotation.Value;  
  
  
import java.io.ByteArrayInputStream;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.math.BigDecimal;  
import java.text.SimpleDateFormat;  
import java.util.ArrayList;  
import java.util.List;  
public class FileStorageUtil {  
    public static AWSCredentials awsCredentials;  
    @Value("${access_key}")  
    public static String access_key = "SK3A9042W5IMUJ1WET8V";  
    @Value("${secret_key}")  
    private static String secret_key = "c1BgQ8ge9OkZ0rZRSQp985Gauoxjv6laKGH3z02v";  
    @Value("${endPoint}")  
    private static String endPoint = "192.168.13.101";  
    private static AmazonS3 conn;  
    private SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm");//设置日期格式  
  
    /** 
     * 创建连接，连接S3服务器 
     */  
    public void creatConnect() {  
        if (awsCredentials == null) {  
            awsCredentials = new BasicAWSCredentials(access_key, secret_key);  
            ClientConfiguration clientConfig = new ClientConfiguration();  
            clientConfig.setProtocol(Protocol.HTTP);  
            conn = new AmazonS3Client(awsCredentials, clientConfig);  
            conn.setEndpoint(endPoint);  
        }  
  
    }  
  
    public AmazonS3 getConnect() {  
        return conn;  
    }  
  
    /** 
     * 获取该连接下所有的容器信息 
     * @return 
     */  
    public List<Bucket> getBuckets() {  
        List<Bucket> buckets = conn.listBuckets();  
        return buckets;  
    }  
  
    public Bucket getBuketsByname(String bucketName) {  
        Bucket resultBucket = null;  
        if (bucketName.isEmpty()) {  
            return null;  
        }  
        List<Bucket> buckets = conn.listBuckets();  
        if(buckets == null){  
            return resultBucket;  
        }  
        for (Bucket bucket : buckets) {  
            if (bucketName.equals(bucket.getName())) {  
                resultBucket = bucket;  
                break;  
            }  
        }  
        return resultBucket;  
    }  
  
    /** 
     * 新建容器名称 
     * @param bucketName 
     * @return 
     */  
    public Bucket creatBucket(String bucketName) {  
        if (bucketName.isEmpty()) {  
            return null;  
        }  
        Bucket bucket = conn.createBucket(bucketName);  
  
        return bucket;  
    }  
  
    /** 
     * 获取该容器下面的所有信息（文件目录集合和文件信息集合） 
     * @param bucketName 
     * @return 
     */  
    public ObjectListing getBacketObjects(String bucketName) {  
        if (bucketName.isEmpty()) {  
            return null;  
        }  
        ObjectListing objects = conn.listObjects(bucketName);  
        return objects;  
    }  
  
    /** 
     * 获取某个文件（前缀路径）下的所有信息 
     * @param bucketName 
     * @param prefix 
     * @param isDelimiter 
     * @return 
     */  
    public ObjectListing getBacketObjects(String bucketName, String prefix,Boolean isDelimiter ) {  
        if ( bucketName == null || bucketName.isEmpty()) {  
            return null;  
        }  
        ListObjectsRequest objectsRequest = new ListObjectsRequest().withBucketName(bucketName);  
        if (prefix != null && !prefix.isEmpty()) {  
            objectsRequest = objectsRequest.withPrefix(prefix);  
        }  
        if(isDelimiter){  
            objectsRequest = objectsRequest.withDelimiter("/");  
        }  
        ObjectListing objects = conn.listObjects(objectsRequest);  
        return objects;  
    }  
  
    /** 
     * 获取当前容器下面的目录集合 
     * @param objects 
     * @return 
     */  
    public List<StorageObjectVo> getDirectList(ObjectListing objects) {  
        List<StorageObjectVo> diectList = new ArrayList<StorageObjectVo>();  
        String prefix = objects.getPrefix();  
        do {  
            List<String> commomprefix = objects.getCommonPrefixes();  
  
            for (String comp : commomprefix) {  
                StorageObjectVo dirStorageObjectVo = new StorageObjectVo();  
                String dirName = comp.substring(prefix == null?0:prefix.length(), comp.length()-1);  
                dirStorageObjectVo.setName(dirName);  
                dirStorageObjectVo.setType("文件夹");  
                diectList.add(dirStorageObjectVo);  
  
            }  
            objects = conn.listNextBatchOfObjects(objects);  
        } while (objects.isTruncated());  
        return diectList;  
    }  
  
  
    /** 
     * 获取当前容器下面的文件集合 
     * @param objects 
     * @return 
     */  
    public List<StorageObjectVo> getFileList(ObjectListing objects) {  
        List<StorageObjectVo> fileList = new ArrayList<StorageObjectVo>();  
        String prefix = objects.getPrefix();  
        do {  
            for (S3ObjectSummary objectSummary : objects.getObjectSummaries()) {  
                System.out.println(objectSummary.getKey() + "\t" + objectSummary.getSize() + "\t" + StringUtils.fromDate(objectSummary.getLastModified()));  
                if(prefix!= null  && objectSummary.getKey().equals(prefix.trim())){  
                    continue;  
                }  
                StorageObjectVo fileStorageObjectVo = new StorageObjectVo();  
                String fileName = objectSummary.getKey().substring(prefix == null?0:prefix.length(), objectSummary.getKey().length());  
//                fileStorageObjectVo.setName(objectSummary.getKey());  
                fileStorageObjectVo.setName(fileName);  
                fileStorageObjectVo.setType("文件");  
                fileStorageObjectVo.setSize(bytes2kb(objectSummary.getSize()));  
                fileStorageObjectVo.setDate(df.format(objectSummary.getLastModified()));  
                fileList.add(fileStorageObjectVo);  
            }  
            objects = conn.listNextBatchOfObjects(objects);  
        } while (objects.isTruncated());  
        return fileList;  
    }  
  
    public List<StorageObjectVo> getObjectList(String bucketName, String prefix) {  
        if ( bucketName == null && bucketName.isEmpty()) {  
            return null;  
        }  
        ListObjectsRequest objectsRequest = new ListObjectsRequest().withBucketName(bucketName);  
        if (prefix!=null &&  !prefix.isEmpty()) {  
            objectsRequest = objectsRequest.withPrefix(prefix);  
        }  
        objectsRequest = objectsRequest.withDelimiter("/");  
        ObjectListing objects = conn.listObjects(objectsRequest);  
        List<StorageObjectVo> resultList = new ArrayList<StorageObjectVo>();  
        List<StorageObjectVo> dirList = getDirectList(objects);  
        if (dirList != null && dirList.size() > 0) {  
            resultList.addAll(dirList);  
        }  
        List<StorageObjectVo> fileList = getFileList(objects);  
        if (fileList != null && fileList.size() > 0) {  
            resultList.addAll(fileList);  
        }    
        return resultList;  
    }  
    //创建文件目录  
    public  Boolean creatpath(String bucketName,String StorageObjectVoPath,  String folderName){  
        if(bucketName == null || folderName == null){  
            return  false;  
        }  
        if(StorageObjectVoPath == null || StorageObjectVoPath.isEmpty()|| "null".equals(StorageObjectVoPath)){  
            StorageObjectVoPath ="";  
        }  
        String key = StorageObjectVoPath + folderName+"/";  
        ByteArrayInputStream local = new ByteArrayInputStream("".getBytes());  
        PutObjectResult result =   conn.putObject(bucketName, key, local, new ObjectMetadata());  
        return  true;  
  
    }  
  
    public Boolean deleteBucket(String bucketName) {  
        if (bucketName.isEmpty()) {  
            return false;  
        }  
        Bucket bucket = conn.createBucket(bucketName);  
        conn.deleteBucket(bucket.getName());  
        return true;  
    }  
  
    /** 
     * 
     * 上传 文件对象到容器 
     * @param bucketName 
     * @param StorageObjectVoPath 
     * @param fileName 
     * @param uploadFile 
     * @return 
     */  
    public PutObjectResult creatObject(String bucketName,String StorageObjectVoPath, String fileName, File uploadFile) {  
        if(StorageObjectVoPath == null || StorageObjectVoPath.isEmpty()|| "null".equals(StorageObjectVoPath)){  
            StorageObjectVoPath ="";  
        }  
        if(uploadFile == null){  
            return  null;  
        }  
        String fileAllPath = StorageObjectVoPath + fileName;  
        FileInputStream inputStream = null;  
        try {  
            inputStream = new FileInputStream(uploadFile);  
  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        }  
        PutObjectResult result = conn.putObject(bucketName, fileAllPath, inputStream, new ObjectMetadata());  
        return result;  
    }  
  
  
    public void changeOBjectACL(String bucketName, String ObjectName, CannedAccessControlList aceess) {  
        conn.setObjectAcl(bucketName, ObjectName, aceess);  
    }  
  
  
    public ObjectMetadata download(String bucketName, String objectName, File destinationFile) {  
        if (bucketName.isEmpty() || objectName.isEmpty()) {  
            return null;  
        }  
        ObjectMetadata result = conn.getObject(new GetObjectRequest(bucketName, objectName), destinationFile);  
        return result;  
    }  
    public S3Object download(String bucketName, String objectName) {  
        if (bucketName.isEmpty() || objectName.isEmpty()) {  
            return null;  
        }  
        S3Object  object = conn.getObject(bucketName, objectName);  
        return object;  
    }  
  
    public Boolean deleteObject(String bucketName, String objectName) {  
        if (bucketName.isEmpty() || objectName.isEmpty()) {  
            return false;  
        }  
        conn.deleteObject(bucketName, objectName);  
        return true;  
    }  
  
    /**生成文件url 
     * 
     * @param bucketName 
     * @param objectName 
     * @return 
     */  
    public String getDownloadUrl(String bucketName, String objectName) {  
        if (bucketName.isEmpty() || objectName.isEmpty()) {  
            return null;  
        }  
        GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, objectName);  
        System.out.println(conn.generatePresignedUrl(request));  
        return conn.generatePresignedUrl(request).toString();  
    }  
  
    /** 
     * 移动对象信息到目标容器 
     * @param OrgbucketName 
     * @param orgKey 
     * @param destinationName 
     * @param destinationKey 
     * @return 
     */  
    public Boolean moveObject(String OrgbucketName,String orgKey,String destinationName,String destinationKey){  
        CopyObjectResult result=conn.copyObject(OrgbucketName, orgKey, destinationName, destinationKey);  
        Boolean isDelete=deleteObject(OrgbucketName,orgKey);  
        if(result!=null){  
            return isDelete;  
        }  
        return false;  
    }  
  
    /** 
     * 移动目标文件夹信息到目标容器 
     * @param objects 
     * @param destinationBucket 
     * @return 
     */  
    public Boolean moveForder(ObjectListing objects,String destinationBucket){  
        String bucketName = objects.getBucketName();  
        do {  
            for (S3ObjectSummary objectSummary : objects.getObjectSummaries()) {  
                System.out.println(objectSummary.getKey() + "\t" + objectSummary.getSize() + "\t" + StringUtils.fromDate(objectSummary.getLastModified()));  
                CopyObjectResult result=conn.copyObject(bucketName, objectSummary.getKey(), destinationBucket,  objectSummary.getKey());  
                Boolean isDelete=deleteObject(bucketName, objectSummary.getKey());  
            }  
            objects = conn.listNextBatchOfObjects(objects);  
        } while (objects.isTruncated());  
        return  true;  
    }  
  
    /** 
     * 删除文件夹内容（必须先遍历删除文件夹内的内容） 
     * @param objects 
     * @return 
     */  
    public Boolean deleteForder(ObjectListing objects){  
        String bucketName = objects.getBucketName();  
        do {  
            for (S3ObjectSummary objectSummary : objects.getObjectSummaries()) {  
                System.out.println(objectSummary.getKey() + "\t" + objectSummary.getSize() + "\t" + StringUtils.fromDate(objectSummary.getLastModified()));  
                Boolean isDelete=deleteObject(bucketName, objectSummary.getKey());  
            }  
            objects = conn.listNextBatchOfObjects(objects);  
        } while (objects.isTruncated());  
        return  true;  
    }  
  
    /** 
     * 将文件大小格式转为MB格式 
     * @param bytes 
     * @return 
     */  
    public static String bytes2kb(long bytes) {  
        BigDecimal filesize = new BigDecimal(bytes);  
        BigDecimal megabyte = new BigDecimal(1024 * 1024);  
        float returnValue = filesize.divide(megabyte, 2, BigDecimal.ROUND_UP)  
                .floatValue();  
        if (returnValue > 1)  
            return (returnValue + "MB");  
        BigDecimal kilobyte = new BigDecimal(1024);  
        returnValue = filesize.divide(kilobyte, 2, BigDecimal.ROUND_UP)  
                .floatValue();  
        return (returnValue + "KB");  
    }  
}

　　

转载于:https://www.cnblogs.com/xxj-bigshow/p/9146753.html

Amazon S3功能分析
liuhong的专栏
10-29 2100
对外提供功能： 1、基本功能： 1）能够读，写，删除1B-5TB大小的数据，单次请求可以删除1000个对象； 2）对开发者提供REST，SOAP协议；下载默认协议为http，如果使用 BitTorrent ，费用更低； 2、桶： 1）一次可以创建100一个桶； 2）桶有一定的命名规则； 3）支持的操作：创建，删除，元数据，list； 4）list操作： 一次list的
探索亚马逊Amazon S3：无缝存储管理与极速数据传输的奥秘
ztK63LrD的博客
08-05 2417
亚马逊云科技中Amazon S3，因其设计简单与高度可靠，允许用户通过互联网存储和检索任意数量的数据，并能够自动扩展以满足各种规模的需求，使得Amazon S3成为了许多云计算应用和网站的核心存储基础设施之一，Amazon S3提供的功能涉及方面众多，今天博主就云存储服务这一方面知识简单讲解一下Amazon S3。
亚马逊S3接口文档
06-13
Amazon Simple Storage Service 文档。提供了 Amazon S3 的概念性介绍，以及使用各种功能的详细说明。
Amazon S3简介
qq_37432174的博客
02-17 3146
Amazon 最早推出的两项云服务：EC2 和 S3。Amazon S3：Amazon Simple Storage Service（亚马逊简易存储服务）；EC2 ：Elastic Compute Cloud（弹性计算云,即云中的虚拟服务器）；Amazon S3支持REST风格，即通过GET、PUT、DELETE、POST、PATCH操作服务端的资源;Amazon S3 操作：Service，Buckets和Objects。
亚马逊S3简单介绍
mikewuhao的博客
06-23 3846
Amazon S3介绍 Amazon Simple Storage Service (Amazon S3) 是一种对象存储，它具有简单的 Web 服务接口，可用于在 Web 上的任何位置存储和检索任意数量的数据。它能够提供 99.999999999% 的持久性，并且可以在全球大规模传递数万亿对象。 S3的基本数据结构 S3的数据存储结构非常简单，就是一个扁平化的两层结构：一层是存储桶（Bucket，又称存储段），另一层是存储对象（Object，又称数据元）。存储桶是S3中用来归类数据的一个方式，它是数据存储
Amazon S3
Beal的博客
01-18 1391
Amazon S3：https://amazonaws-china.com/cn/s3/faqs/        Amazon S3 是一种对象存储，专为从 Internet 上的任意位置存储和检索任意数量的数据而构建。它是一种简单的存储服务，以非常低的成本提供极其持久、高度可用并可无限扩展的数据存储基础设施。        Amazon S3 提供一个简单的 Web 服务界面，使用该界面，您...
亚马逊s3-api文档.pdf
09-30
亚马逊S3 API文档是Amazon Simple Storage Service (S3)的官方参考手册，它详细描述了如何使用S3的REST API进行数据的存储和检索。文档中包含了关于如何操作S3的基本概念、使用方法、身份验证以及数据类型等重要信息...
Amazon S3 Tools：S3cmd 介绍
DHclly的博客
11-22 1284
Windows 11、Windows 10、Windows 8 / 8.1、Windows 7、Windows Vista、XP、Windows Server 2022、2019、2016、2012、2008、2003，包括。使用 S3Express，您可以使用条件过滤器列出和查询 S3 对象，管理 S3 对象的元数据和 ACL，使用分段上传和多个并发线程将文件上传到 S3，仅将新的或更改的文件上传到 S3 以进行自动备份（=），使用 Windows 命令行删除多个 S3 对象、复制 S3 对象等。
MinIO是与Amazon S3 API兼容的高性能对象存储服务器-Golang开发
05-26
它与Amazon S3云存储服务兼容。 MinIO最适合存储照片，视频，日志等非结构化数据。MinIO快速入门指南MinIO是根据Apache License v2.0发布的高性能对象存储。 它与Amazon S3云存储服务兼容。 使用MinIO构建用于机器...
【AWS入门】Amazon S3简介
最新发布
jackson_lingua的博客
03-18 1379
本文简要介绍数据存储类型，以及通过获取官方数据，来组织一场关于亚马逊存储的需要讨论吧。
【亲测免费】 探索高性能Amazon S3客户端：你的云存储助手
gitblog_00719的博客
08-10 640
探索高性能Amazon S3客户端：你的云存储助手 在当今数据密集型的世界中，云端存储和管理数据的需求日益增加。Amazon Simple Storage Service（S3）已成为行业标准的云存储解决方案之一。然而，在处理大规模文件传输和复杂操作时，直接利用S3的API可能变得繁琐且效率低下。这时，一款强大的工具——High-Level Amazon S3 Client应运而生。 高性能S3客...
AWS——03篇（AWS之Amazon S3（云中可扩展存储）-01入门）
@素素~的博客
08-09 5005
AWS——03篇（AWS之Amazon S3（云中可扩展存储）-01入门）
高级Amazon S3客户端库的深度解析与应用指南
gitblog_00045的博客
05-09 430
高级Amazon S3客户端库的深度解析与应用指南 在这个数字化时代，云存储已经成为数据管理和备份的重要方式之一，Amazon S3以其稳定性和高扩展性赢得了全球用户的信赖。对于开发者来说，有一款高效且可靠的S3客户端库至关重要。为此，我们向您推荐一个开源项目——High Level Amazon S3 Client，它将帮助您更方便地操作S3服务。 项目简介 这个项目是一个强大的Node.js客...
Amazon aws s3上传文件，在给定bucket新建文件夹
lixld的专栏
09-10 8811
直接上硬菜： 1.依赖 <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-s3</artifactId> <version>1.11.625</version> </dependency&g...
aws s3性能优化实践
流年似水的专栏
12-13 1389
使用aws s3 sdk的性能优化实践
AWS S3桶 配置访问权限（AKSK）的流程
dwe147的博客
08-12 6646
为了能访问有权限限制的AWS S3桶，需要在访问S3桶的机器上配置AKSK
S3-boto3
yequn1997的博客
11-18 1585
1. list_objects(**kwargs) 定义： 返回存储桶中的部分或全部对象（最多 1,000 个）。 可以使用请求参数作为选择标准来返回存储桶中对象的子集。 200 OK 响应可以包含有效或无效的 XML。 请求语法： response = client.list_objects( Bucket='string', Delimiter='string', EncodingType='url', Marker='string', MaxKeys
aws s3 的上传与删除
daoerZ的博客
08-08 1134
pom.xml引入s3的依赖 <!--AWS S3上传依赖--> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-s3</artifactId> <version>1.11.172</version> </dependency>
Amazon S3数据存储
weixin_30340819的博客
11-12 377
从官网下载aws 的unity插件，并做了简单修改（主要用修改PostObject），问题： （一）获取Pool ID 通过服务-Cognito-管理/新建用户池，可以新建或者获取Pool ID （二）上传失败问题 使用unity插件中S3Example中PostObject时抛异常，但是获取GetObject没问题，此时需要在上传时代码中加一下区域，如下图所示。如果此时正在***，请...
自动化 PostgreSQL 备份转储到 Amazon S3 工具介绍
Amazon S3是亚马逊推出的一种对象存储服务，广泛用于存储和保护大量数据。它提供高可用性和扩展性强的存储解决方案，非常适合于备份和归档等场景。 4. 数据备份管理：pg_dump-to-s3可能具备对上传文件的管理功能，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值