一，阿里云OSS简介
阿里云 OSS 是一款安全、稳定且具备无限扩容能力的云端对象存储服务，专为高效存储图片、视频、文档及备份数据而设计。其核心优势在于：
广泛应用于网站、小程序及直播平台等场景，是替代本地存储、实现静态资源云端化管理的理想选择。
二，如何使用阿里云OSS
第一步：登录阿里云： https://www.aliyun.com
第二步：开通对象存储服务OSS 依次点击 “产品” -> “对象存储OSS” -> “对象存储 OSS控制台” -> “立即开通” -> “立即购买” -> “去支付” -> “支付”
接下来打开：
https://www.aliyun.com/product/oss
点：立即购买
第三步：创建 Bucket
进入OSS管理控制台，点击 “Bucket 列表”、“创建 Bucket”
自定义 Bucket 名称、添加地域属性（距离自己最近）
点击 “完成创建”
进入创建好的 Bucket
点击 “权限控制” 下的 “阻止公共访问”，确认关闭
再点击 “读写权限”，设置 “公共读”
第四步：RAM 申请
RAM（访问控制）是阿里云提供的资源权限管理服务。RAM 用户代表通过控制台或 OpenAPI 操作阿里云资源的个人、系统或应用程序。该服务允许您在云账号下创建并管理多个独立用户，每个用户均拥有唯一的用户名及登录凭证（密码或 AccessKey）。
云账号与 RAM 用户之间构成主从关系，具体定义如下：
1. 云账户（主账号）
- 资源归属主体：拥有阿里云资源的最终所有权。
- 计费主体：负责所有资源的使用计量与费用结算。
2. RAM 用户（子账号）
- 依附性：必须存在于某个云账号下的 RAM 实例中，无法独立存在。
- 无资源所有权：自身不拥有任何资源；在被授权操作期间所创建的资源，其所有权归属于主账号。
- 无独立账单：不持有独立账单；在被授权操作期间产生的所有费用，均计入主账号账单。
（1）新建RAM用户
鼠标悬停在右上角的头像上，然后进入“AccessKey”
点击 “使用 RAM 用户 AccessKey”
点击 “创建用户”
注意：创建完成后会得到 AccessKey ID 和 AccessKey Secret，一定要保存下来，后续会使用到，并且出现一次后不会再出现！！！ （2）添加本机系统环境变量 “设置” -> “编辑系统环境变量” -> “环境变量” -> “新建（系统变量）” 分别添加 “ALIBABA_CLOUD_ACCESS_KEY_ID” 和 “ALIBABA_CLOUD_ACCESS_KEY_SECRET”，对应（1）中保存的值
（3）分配权限
本步骤不确定是否对后续结果有影响，6个权限也是直接搜索 oss 添加。可跳过，若之后出错再考虑添加 !
点击 “添加权限”
第五步：Java 项目文件上传 点击 “SDK下载”，再点击 “Java” 旁边的小图标，“文档中心打开”
进入页面后下划到底部，点击 “安装”
（1）添加本机环境变量 “OSS_ACCESS_KEY_ID”、“OSS_ACCESS_KEY_SECRET” 即 RAM 的 ID 和 密码
方式 2：
（2）导入依赖 进入自定义项目的 pom.xml 文件：
（3）新建 java文件 ResultDTO.java
import lombok.Getter;
@Getter
public class ResultDTO {
private final int code; // 状态码（0表示成功）
private final String msg; // 消息说明
private final Object data; // 返回数据（如 URL）
private ResultDTO(int code, String msg, Object data) {
this.code = code;
this.msg = msg;
this.data = data;
}
public static ResultDTO success(String url) {
return new ResultDTO(0, "success", url);
}
}
AliOSSUtil.java
import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.PutObjectRequest;
import com.aliyun.oss.model.PutObjectResult;
import java.io.FileInputStream;
import java.io.InputStream;
public class AliOSSUtil {
// bucket概述：访问端口-外网访问-Endpoint（地域节点）
private static final String ENDPOINT = "https://oss-cn-qingdao.aliyuncs.com";
// 密钥
private static final String ACCESS_KEY_ID = "your_AccessKey_ID";
private static final String ACCESS_KEY_SECRET = "your_AccessKey_Secret";
// bucket概述：存储空间名称
private static final String BUCKET_NAME = "your_ducket_name";
// objectName: 图片名称(包含后缀), in: 输入流
public static String uploadFile(String objectName, InputStream in) {
// 创建OSSClient实例。
OSS ossClient = new OSSClientBuilder().build(ENDPOINT,ACCESS_KEY_ID,ACCESS_KEY_SECRET);
// 返回OSS图片地址
String url = "";
try {
// 创建PutObjectRequest对象。
PutObjectRequest putObjectRequest = new PutObjectRequest(BUCKET_NAME, objectName, in);
// 创建PutObject请求。
PutObjectResult result = ossClient.putObject(putObjectRequest);
// 文件上传成功后外网访问地址。 示例: https://bucket-yangyang-one.oss-cn-qingdao.aliyuncs.com/1.png
url = "https://" + BUCKET_NAME + "." + ENDPOINT.substring(ENDPOINT.lastIndexOf("/")+1) + "/" + objectName;
} catch (OSSException oe) {
System.out.println("Caught an OSSException, which means your request made it to OSS, "
+ "but was rejected with an error response for some reason.");
System.out.println("Error Message:" + oe.getErrorMessage());
System.out.println("Error Code:" + oe.getErrorCode());
System.out.println("Request ID:" + oe.getRequestId());
System.out.println("Host ID:" + oe.getHostId());
} catch (ClientException ce) {
System.out.println("Caught an ClientException, which means the client encountered "
+ "a serious internal problem while trying to communicate with OSS, "
+ "such as not being able to access the network.");
System.out.println("Error Message:" + ce.getMessage());
} finally {
if (ossClient != null) {
ossClient.shutdown();
}
}
return url;
}
}
FileUploadController.java
import cn.edu.ldu.dto.ResultDTO;
import cn.edu.ldu.utils.AliOSSUtil;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.util.UUID;
@RestController
@RequestMapping(value = "/file")
public class FileUploadController {
@RequestMapping(method = RequestMethod.POST, value = "/upload")
public ResultDTO upload(MultipartFile file) throws IOException {
String originalFilename = file.getOriginalFilename();
String originalFileType = originalFilename.substring(originalFilename.lastIndexOf("."));
String filename = UUID.randomUUID() + originalFileType;
String url = AliOSSUtil.uploadFile(filename, file.getInputStream());
return ResultDTO.success(url);
}
}
（4）调试 运行代码，使用 Postman 进行调试：
成功上传图片文件！
第六步：PHP 项目文件上传 （1）系统环境要求 • PHP 5.3及以上版本 • cURL扩展支持 （2）快速安装方法 使用Composer安装（推荐） 在项目根目录下运行以下命令：
composer require aliyuncs/oss-sdk-php
手动安装方式 下载SDK源代码后，在代码中引入autoload.php文件：
use OSS\\OssClient;
$accessKeyId = "your_access_key_id";
$accessKeySecret = "your_access_key_secret";
$endpoint = "http://oss-cn-hangzhou.aliyuncs.com"; // 替换为实际的OSS endpoint
$bucketName = "your_bucket_name";
$client = new OssClient($accessKeyId, $accessKeySecret, $endpoint);
（3）初始化客户端
首先，你需要你的阿里云账号的Access Key ID和Access Key Secret。接下来，初始化OssClient对象：
use OSS\\OssClient;
$accessKeyId = "your_access_key_id";
$accessKeySecret = "your_access_key_secret";
$endpoint = "http://oss-cn-hangzhou.aliyuncs.com"; // 替换为实际的OSS endpoint
$bucketName = "your_bucket_name";
$client = new OssClient($accessKeyId, $accessKeySecret, $endpoint);
（4）创建存储桶
$bucketName = "my-test-bucket";
try {
$ossClient->createBucket($bucketName);
echo "存储桶创建成功！";
} catch (OssException $e) {
echo "创建失败：" . $e->getMessage();
}
（5）上传文件到OSS
$objectName = "example.txt";
$content = "Hello, Alibaba Cloud OSS!";
try {
$ossClient->putObject($bucketName, $objectName, $content);
echo "文件上传成功！";
} catch (OssException $e) {
echo "上传失败：" . $e->getMessage();
}
（6）下载文件
$key = "file.txt";
$saveAsFile = "/path/to/save/file.txt";
$result = $client->getOssUrl($bucketName, $key);
file_put_contents($saveAsFile, file_get_contents($result));
第七步：Python 项目文件上传
（1）环境准备与安装
在使用Python操作OSS前，需安装官方提供的SDK：
pip install oss2
安装完成后，需准备阿里云访问密钥（AccessKey ID和AccessKey Secret）以及目标Bucket所在的地域Endpoint。
（2）初始化OSS客户端
使用oss2库连接OSS服务，需创建Auth认证对象和Bucket实例：
import oss2
# 替换为实际的AccessKey信息
auth = oss2.Auth('your-access-key-id', 'your-access-key-secret')
bucket = oss2.Bucket(auth, 'https://oss-cn-beijing.aliyuncs.com', 'your-bucket-name')
上述代码中，auth用于身份验证，bucket代表操作的目标存储空间。
（3）单文件上传处理
import alibabacloud_oss_v2 as oss
# 配置
accessKeyId = "***************"
accessKeySecret = "#########"
customRegion = "cn-%%%%%%"
customeBucket = "&&&&&&&&&"
# 配置静态访问凭证（生产环境不推荐硬编码）
static_cred = oss.credentials.StaticCredentialsProvider(
access_key_id=accessKeyId,
access_key_secret=accessKeySecret,
)
def init_client():
cfg = oss.config.load_default()
cfg.credentials_provider = static_cred
cfg.region = customRegion
return oss.Client(cfg)
def multi_upload(files_map):
"""
:param files_map: 字典类型 { "目标object路径": "本地文件绝对路径" }
"""
client = init_client()
uploader = client.uploader()
for obj_key, local_path in files_map.items():
try:
request = oss.PutObjectRequest(bucket=customeBucket, key=obj_key)
result = uploader.upload_file(
request,
filepath=local_path,
part_size=10 * 1024 * 1024, # 分片大小10MB
part_num=3, # 并发分片数
)
print(f"文件 {local_path} 上传成功，ETag: {result.etag}")
except oss as e:
print(f"上传失败：{e.message}")
if __name__ == "__main__":
# 定义多文件映射（目标路径:本地路径）
file_mapping = {
"sunwukongtest/index.html": "C:/Users/57307/Desktop/Test/TestHtml/index.html",
"sunwukongtest/index1.html": "C:/Users/57307/Desktop/Test/TestHtml/index1.html",
"sunwukongtest/index2.html": "C:/Users/57307/Desktop/Test/TestHtml/index2.html",
"sunwukongtest/index3.html": "C:/Users/57307/Desktop/Test/TestHtml/index3.html",
"sunwukongtest/index4.html": "C:/Users/57307/Desktop/Test/TestHtml/index4.html",
}
multi_upload(file_mapping)
（4）分片上传
import os
import alibabacloud_oss_v2 as oss
# 配置
accessKeyId = "***************"
accessKeySecret = "#########"
customRegion = "cn-%%%%%%"
customeBucket = "&&&&&&&&&"
# 配置静态访问凭证（生产环境不推荐硬编码）
static_cred = oss.credentials.StaticCredentialsProvider(
access_key_id=accessKeyId,
access_key_secret=accessKeySecret,
)
def init_client():
cfg = oss.config.load_default()
cfg.credentials_provider = static_cred
cfg.region = customRegion
return oss.Client(cfg)
def multi_upload(files_map):
"""
:param files_map: 字典类型 { "目标object路径": "本地文件绝对路径" }
"""
client = init_client()
for obj_key, local_path in files_map.items():
# 初始化分片上传请求，获取upload_id用于后续分片上传
result = client.initiate_multipart_upload(
oss.InitiateMultipartUploadRequest(
bucket=customeBucket,
key=obj_key,
)
)
# 定义每个分片的大小为5MB
part_size = 5 * 1024 * 1024
# 获取要上传文件的总大小
data_size = os.path.getsize(local_path)
# 初始化分片编号，从1开始
part_number = 1
# 存储每个分片上传的结果
upload_parts = []
# 打开文件以二进制模式读取
with open(local_path, "rb") as f:
# 遍历文件，按照part_size分片上传
for start in range(0, data_size, part_size):
n = part_size
if start + n > data_size: # 处理最后一个分片可能小于part_size的情况
n = data_size – start
# 创建SectionReader来读取文件的特定部分
reader = oss.io_utils.SectionReader(oss.io_utils.ReadAtReader(f), start, n)
# 上传分片
up_result = client.upload_part(
oss.UploadPartRequest(
bucket=customeBucket,
key=obj_key,
upload_id=result.upload_id,
part_number=part_number,
body=reader,
)
)
# 打印每个分片上传的结果信息
print(
f"status code: {up_result.status_code},"
f" request id: {up_result.request_id},"
f" part number: {part_number},"
f" content md5: {up_result.content_md5},"
f" etag: {up_result.etag},"
f" hash crc64: {up_result.hash_crc64},"
)
# 将分片上传结果保存到列表中
upload_parts.append(
oss.UploadPart(part_number=part_number, etag=up_result.etag)
)
# 增加分片编号
part_number += 1
# 对上传的分片按照分片编号排序
parts = sorted(upload_parts, key=lambda p: p.part_number)
# 发送完成分片上传请求，合并所有分片为一个完整的对象
result = client.complete_multipart_upload(
oss.CompleteMultipartUploadRequest(
bucket=customeBucket,
key=obj_key,
upload_id=result.upload_id,
complete_multipart_upload=oss.CompleteMultipartUpload(parts=parts),
)
)
# 下面的代码是另一种方式，通过服务器端列出并合并所有分片数据为一个完整的对象
# 这种方法适用于当您不确定所有分片是否都已成功上传时
# Merge fragmented data into a complete Object through the server-side List method
# result = client.complete_multipart_upload(oss.CompleteMultipartUploadRequest(
# bucket=args.bucket,
# key=args.key,
# upload_id=result.upload_id,
# complete_all='yes'
# ))
# 输出完成分片上传的结果信息
print(
f"status code: {result.status_code},"
f" request id: {result.request_id},"
f" bucket: {result.bucket},"
f" key: {result.key},"
f" location: {result.location},"
f" etag: {result.etag},"
f" encoding type: {result.encoding_type},"
f" hash crc64: {result.hash_crc64},"
f" version id: {result.version_id},"
)
if __name__ == "__main__":
# 定义多文件映射（目标路径:本地路径）
file_mapping = {
"sunwukongtest/indx.html": "C:/Users/57307/Desktop/Test/TestHtml/index.html",
}
multi_upload(file_mapping)
第八步：C# 项目文件上传
（1）安装阿里云 OSS C# SDK
首先，你需要在项目中引入阿里云 OSS 的 SDK。可以通过 NuGet 来安装阿里云的 OSS 客户端 SDK。
在 Visual Studio 中打开 NuGet 包管理器控制台，执行以下命令：
Install-Package Aliyun.OSS.SDK.NetCore
（2）配置阿里云 OSS 客户端 要使用 OSS 服务，你需要配置 AccessKeyId、AccessKeySecret 和 Endpoint，这三个参数是连接到 OSS 服务的必备信息
using Aliyun.OSS;
using System;
class OSSExample
{
private static string accessKeyId = "你的AccessKeyId";
private static string accessKeySecret = "你的AccessKeySecret";
private static string endpoint = "http://oss-cn-hangzhou.aliyuncs.com"; // 区域Endpoint，根据实际情况修改
private static string bucketName = "你的bucket名称";
static void Main(string[] args)
{
var client = new OssClient(endpoint, accessKeyId, accessKeySecret);
Console.WriteLine("客户端初始化成功！");
}
}
（3）常用操作及参数详解 a，创建 OSS 客户端对象
OssClient client = new OssClient(endpoint, accessKeyId, accessKeySecret);
- endpoint：阿里云 OSS 的域名，可以在阿里云控制台获取。
- accessKeyId 和 accessKeySecret：是你在阿里云控制台创建的密钥，用于身份验证。
b，上传文件到 OSS
/// <summary>
/// 上传本地文件到阿里云OSS
/// </summary>
/// <param name="localFilePath">本地文件完整路径</param>
/// <param name="ossObjectName">OSS中存储的文件路径+名称（如：hnt/20221227171528.jpg）</param>
/// <exception cref="ArgumentNullException">参数为空时抛出</exception>
/// <exception cref="FileNotFoundException">本地文件不存在时抛出</exception>
public void UploadFileToOss(string localFilePath, string ossObjectName)
{
// 入参合法性校验
if (string.IsNullOrWhiteSpace(localFilePath))
throw new ArgumentNullException(nameof(localFilePath), "本地文件路径不能为空");
if (string.IsNullOrWhiteSpace(ossObjectName))
throw new ArgumentNullException(nameof(ossObjectName), "OSS对象名称不能为空");
if (!File.Exists(localFilePath))
throw new FileNotFoundException("本地文件不存在", localFilePath);
try
{
// 创建客户端并执行上传
var client = CreateOssClient();
client.PutObject(bucketName, ossObjectName, localFilePath);
Console.WriteLine($"文件上传成功！OSS路径：{ossObjectName}");
}
catch (OssException ex)
{
// 捕获OSS专属异常（含错误码），便于定位问题
Console.WriteLine($"OSS上传异常：错误码={ex.ErrorCode}，错误信息={ex.Message}");
throw; // 抛出异常让上层处理
}
catch (Exception ex)
{
Console.WriteLine($"文件上传失败：{ex.Message}");
throw;
}
}
- bucketName：目标存储空间名称。
- objectName：文件在 OSS 中的对象名称。
- localFile：本地文件路径。
c，下载文件
/// <summary>
/// 从阿里云OSS下载文件到本地
/// </summary>
/// <param name="ossObjectName">OSS中的文件路径+名称</param>
/// <param name="localSavePath">本地保存的完整路径</param>
/// <exception cref="ArgumentNullException">参数为空时抛出</exception>
public void DownloadFileFromOss(string ossObjectName, string localSavePath)
{
// 入参合法性校验
if (string.IsNullOrWhiteSpace(ossObjectName))
throw new ArgumentNullException(nameof(ossObjectName), "OSS对象名称不能为空");
if (string.IsNullOrWhiteSpace(localSavePath))
throw new ArgumentNullException(nameof(localSavePath), "本地保存路径不能为空");
try
{
var client = CreateOssClient();
// 自动创建下载目录（避免目录不存在导致失败）
string saveDirectory = Path.GetDirectoryName(localSavePath);
if (!string.IsNullOrEmpty(saveDirectory) && !Directory.Exists(saveDirectory))
{
Directory.CreateDirectory(saveDirectory);
}
// 构建下载请求并写入本地文件流
var getRequest = new GetObjectRequest(bucketName, ossObjectName);
using (var localFileStream = File.OpenWrite(localSavePath))
{
client.GetObject(getRequest, localFileStream);
}
Console.WriteLine($"文件下载成功！本地路径：{localSavePath}");
}
catch (OssException ex)
{
Console.WriteLine($"OSS下载异常：错误码={ex.ErrorCode}，错误信息={ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"文件下载失败：{ex.Message}");
throw;
}
}
通过指定 OSS 中的对象名来下载文件。
d，删除文件
/// <summary>
/// 删除阿里云OSS中的指定文件
/// </summary>
/// <param name="ossObjectName">OSS中的文件路径+名称</param>
/// <exception cref="ArgumentNullException">参数为空时抛出</exception>
public void DeleteFileFromOss(string ossObjectName)
{
if (string.IsNullOrWhiteSpace(ossObjectName))
throw new ArgumentNullException(nameof(ossObjectName), "OSS对象名称不能为空");
try
{
var client = CreateOssClient();
client.DeleteObject(bucketName, ossObjectName);
Console.WriteLine($"文件删除成功！OSS路径：{ossObjectName}");
}
catch (OssException ex)
{
Console.WriteLine($"OSS删除异常：错误码={ex.ErrorCode}，错误信息={ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"文件删除失败：{ex.Message}");
throw;
}
}
e，列举文件
/// <summary>
/// 获取OSS指定前缀（目录）下的文件列表
/// </summary>
/// <param name="prefix">文件前缀/目录名（如：hnt/，空则查询整个Bucket）</param>
/// <param name="isRecursive">是否递归查询子目录（true=递归，false=仅当前目录）</param>
/// <param name="maxKeys">返回的最大文件数量（默认1000，最大不超过1000）</param>
/// <returns>文件名称列表（完整OSS路径）</returns>
/// <exception cref="ArgumentOutOfRangeException">maxKeys≤0或>1000时抛出</exception>
public List<string> ListFilesInOss(string prefix = "", bool isRecursive = false, int maxKeys = 1000)
{
// 入参校验：maxKeys需在1-1000之间（OSS接口限制）
if (maxKeys <= 0 || maxKeys > 1000)
throw new ArgumentOutOfRangeException(nameof(maxKeys), "最大返回数量需在1-1000之间");
try
{
var client = CreateOssClient();
var listRequest = new ListObjectsRequest(bucketName)
{
Prefix = prefix ?? "", // 前缀（目录），为空则查全部
Delimiter = isRecursive ? null : "/", // 非递归时用/分隔目录，仅返回当前层级
MaxKeys = maxKeys // 最大返回数量
};
// 执行列表查询
var listResult = client.ListObjects(listRequest);
var fileList = new List<string>();
// 遍历结果，收集文件名称（排除目录占位符）
foreach (var objectSummary in listResult.ObjectSummaries)
{
// 过滤掉目录本身（以/结尾的是目录，不是文件）
if (!objectSummary.Key.EndsWith("/"))
{
fileList.Add(objectSummary.Key);
}
}
Console.WriteLine($"获取文件列表成功！前缀：{prefix}，数量：{fileList.Count}");
return fileList;
}
catch (OssException ex)
{
Console.WriteLine($"OSS获取列表异常：错误码={ex.ErrorCode}，错误信息={ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"获取文件列表失败：{ex.Message}");
throw;
}
}
