存储到 亚马逊 S3

使用 AWS S3 存储文件并整合到 Tio-Boot 项目中

本文将详细介绍如何在 AWS S3 上配置存储桶，并将其整合到 Tio-Boot 项目中，实现文件的上传、存储及相关信息的保存到数据库。本文包含所有必要的配置步骤、代码示例及相关说明，确保您能够顺利完成集成。

目录

  1. AW3 S3 配置
  2. 获取访问密钥
  3. 整合到 Tio-Boot 项目中
  4. 测试上传功能
  5. 总结

AW3 S3 配置

创建存储桶

  1. 登录到 AWS 管理控制台。
  2. 转到 S3 服务页面，点击“创建存储桶”。
  3. 输入存储桶名称（如 rumiapp）并选择区域（如 us-west-1）。
  4. 完成其他配置选项后，点击“创建存储桶”。

设置公开权限

为了让存储桶中的内容公开可访问，需要进行以下配置。但请注意，公开存储桶可能会带来数据安全风险，请在确保了解相关风险的情况下操作。

修改桶策略

  1. 使用 AWS 管理控制台

    • 登录到 AWS 管理控制台并转到 S3 服务页面。
    • 选择您要修改权限的存储桶。

  2. 修改桶策略

    • 点击“权限”标签。

    • 找到“桶策略”部分并点击“编辑”。

    • 输入如下策略，允许公开访问（将 your-bucket-name 替换为您的存储桶名称）：

      {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PublicReadGetObject",
      "Effect": "Allow",
      "Principal": "*",
      "Handler": "s3:GetObject",
      "Resource": "arn:aws:s3:::your-bucket-name/*"
    }
  ]
}

    • 保存更改。

禁用阻止公共访问设置

  1. 在“权限”标签下，找到“阻止公共访问（Bucket settings for Block Public Access）”设置。
  2. 点击“编辑”。
  3. 确保所有选项均未勾选，或根据需要调整设置，以允许公共读取访问。
  4. 保存更改。

配置 CORS

如果需要跨域请求资源，请配置 CORS（跨域资源共享）：

  1. 在“权限”标签下，找到“CORS 配置”。

  2. 点击“编辑”，然后输入以下配置，允许任何源的 GET 请求：

    [
  {
    "AllowedHeaders": [],
    "AllowedMethods": ["GET"],
    "AllowedOrigins": ["*"],
    "ExposeHeaders": []
  }
]

  3. 保存更改。

获取访问密钥

为了通过编程方式访问 S3，需要获取 AWS 的访问密钥。

  1. 登录到 AWS IAM 控制台。
  2. 选择“我的安全凭证”。
  3. 在“访问密钥”部分，点击“创建访问密钥”。
  4. 下载或复制生成的访问密钥 ID 和秘密访问密钥，确保妥善保存。

整合到 Tio-Boot 项目中

以下步骤将指导您如何将 AWS S3 集成到 Tio-Boot 项目中，实现文件上传功能。

添加依赖

在您的项目 pom.xml 文件中添加 AWS S3 SDK 依赖：

<dependency>
  <groupId>software.amazon.awssdk</groupId>
  <artifactId>s3</artifactId>
  <version>2.17.100</version> <!-- 请检查并使用最新版本 -->
</dependency>

or

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>software.amazon.awssdk</groupId>
      <artifactId>bom</artifactId>
      <version>2.25.63</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>2.0.1</version>
  </dependency>
  
  <dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>s3</artifactId>
  </dependency>
  <dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>sts</artifactId>
  </dependency>
  <dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>sso</artifactId>
  </dependency>
  <dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>ssooidc</artifactId>
  </dependency>
</dependencies>

添加配置

在项目的 application.properties 文件中添加以下配置：

AWS_S3_ACCESS_KEY_ID=您的访问密钥 ID
AWS_S3_SECRET_ACCESS_KEY=您的秘密访问密钥
AWS_S3_REGION_NAME=us-west-1
AWS_S3_BUCKET_NAME=rumiapp

实现文件上传工具类 AwsS3Utils

创建一个 AwsS3Utils 工具类，用于处理文件上传及生成文件 URL。

package nexus.io.tio.boot.admin.utils.storage;

import java.io.File;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.time.Duration;

import nexus.io.tio.utils.environment.EnvUtils;
import nexus.io.tio.utils.http.ContentTypeUtils;
import nexus.io.tio.utils.hutool.FilenameUtils;

import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.S3ClientBuilder;
import software.amazon.awssdk.services.s3.model.GetObjectRequest;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.PutObjectResponse;
import software.amazon.awssdk.services.s3.presigner.S3Presigner;
import software.amazon.awssdk.services.s3.presigner.model.GetObjectPresignRequest;
import software.amazon.awssdk.services.s3.presigner.model.PresignedGetObjectRequest;

public class AwsS3Utils {

  public static final String urlFormat = "https://%s.s3.%s.amazonaws.com/%s";

  public static final String bucketName = EnvUtils.get("AWS_S3_BUCKET_NAME");
  public static final String regionName = EnvUtils.get("AWS_S3_REGION_NAME");
  public static final String accessKeyId = EnvUtils.get("AWS_S3_ACCESS_KEY_ID");
  public static final String secretAccessKey = EnvUtils.get("AWS_S3_SECRET_ACCESS_KEY");
  public static final String domain = EnvUtils.getStr("AWS_S3_BUCKET_DOMAIN");
  public static final String AWS_PROFILE = EnvUtils.getStr("AWS_PROFILE");

  public static final Duration DEFAULT_PRESIGN_EXPIRES = Duration.ofMinutes(30);

  // -------------------------
  // Upload
  // -------------------------

  public static PutObjectResponse upload(S3Client client, String targetName, byte[] fileContent, String suffix) {
    // TODO Auto-generated method stub
    return upload(client, bucketName, targetName, fileContent, suffix);
  }

  public static PutObjectResponse upload(S3Client client, String bucketName, String targetName, byte[] fileContent,
      String suffix) {
    try {
      String contentType = ContentTypeUtils.getContentType(suffix);
      PutObjectRequest putOb = PutObjectRequest.builder().bucket(bucketName).key(targetName).contentType(contentType)
          .build();

      return client.putObject(putOb, RequestBody.fromBytes(fileContent));
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  public static PutObjectResponse upload(S3Client client, String targetName, File file) {
    String name = file.getName();
    String suffix = FilenameUtils.getSuffix(name);
    String contentType = ContentTypeUtils.getContentType(suffix);
    try {
      PutObjectRequest putOb = PutObjectRequest.builder().bucket(bucketName).key(targetName).contentType(contentType)
          .build();

      return client.putObject(putOb, RequestBody.fromFile(file));
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  public static PutObjectResponse upload(S3Client client, String bucketName, String targetName, File file) {
    String name = file.getName();
    String suffix = FilenameUtils.getSuffix(name);
    String contentType = ContentTypeUtils.getContentType(suffix);
    try {
      PutObjectRequest putOb = PutObjectRequest.builder().bucket(bucketName).key(targetName).contentType(contentType)
          .build();

      return client.putObject(putOb, RequestBody.fromFile(file));
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  // -------------------------
  // Public URL (only works if bucket/object is public or via domain/CDN)
  // -------------------------
  public static String getUrl(String targetUri) {
    if (domain != null) {
      return "https://" + domain + "/" + targetUri;
    } else {
      return String.format(AwsS3Utils.urlFormat, bucketName, regionName, targetUri);
    }
  }

  public static String getUrl(String bucketName, String targetUri) {
    if (domain != null) {
      return "https://" + domain + "/" + targetUri;
    } else {
      return String.format(AwsS3Utils.urlFormat, bucketName, regionName, targetUri);
    }
  }

  public static String getUrl(String regionName, String bucketName, String targetUri) {
    if (domain != null) {
      return "https://" + domain + "/" + targetUri;
    } else {
      return String.format(AwsS3Utils.urlFormat, bucketName, regionName, targetUri);
    }
  }

  // -------------------------
  // Presigned Download URL (works for private bucket)
  // -------------------------
  /**
   * 生成可下载的预签名 GET URL（默认 30 分钟）。
   * 适用于 bucket 私有的场景。
   */
  public static String getPresignedDownloadUrl(String targetUri) {
    return getPresignedDownloadUrl(regionName, bucketName, targetUri, DEFAULT_PRESIGN_EXPIRES, null, null);
  }

  public static String getPresignedDownloadUrl(String bucket, String targetUri) {
    return getPresignedDownloadUrl(regionName, bucket, targetUri, DEFAULT_PRESIGN_EXPIRES, null, null);
  }

  public static String getPresignedDownloadUrl(String regionName, String bucket, String targetUri) {
    return getPresignedDownloadUrl(regionName, bucket, targetUri, DEFAULT_PRESIGN_EXPIRES, null, null);
  }

  public static String getPresignedDownloadUrl(String regionName, String bucket, String targetUri,
      String downloadFilename, String contentType) {
    return getPresignedDownloadUrl(regionName, bucket, targetUri, DEFAULT_PRESIGN_EXPIRES, downloadFilename,
        contentType);
  }

  public static String getPresignedDownloadUrl(String regionName, String bucket, String targetUri,
      String downloadFilename) {
    String suffix = FilenameUtils.getSuffix(downloadFilename);
    String contentType = ContentTypeUtils.getContentType(suffix);
    return getPresignedDownloadUrl(regionName, bucket, targetUri, DEFAULT_PRESIGN_EXPIRES, downloadFilename,
        contentType);
  }

  /**
   * @param bucket  bucket name
   * @param key     object key (targetUri/targetName)
   * @param expires 过期时间（S3 限制：最大 7 天）
   * @param downloadFilename 让浏览器下载时显示的文件名（可选）
   * @param contentType      响应 Content-Type（可选）
   */
  public static String getPresignedDownloadUrl(String regionName, String bucket, String key, Duration expires,
      String downloadFilename, String contentType) {
    if (expires == null) {
      expires = DEFAULT_PRESIGN_EXPIRES;
    }

    try (S3Presigner presigner = buildPresigner(regionName)) {

      GetObjectRequest.Builder getReqBuilder = GetObjectRequest.builder().bucket(bucket).key(key);

      if (downloadFilename != null && downloadFilename.length() > 0) {
        // 同时兼容普通 filename 与 RFC5987 filename*
        String safe = downloadFilename.replace("\"", "");
        String encoded = URLEncoder.encode(downloadFilename, StandardCharsets.UTF_8).replace("+", "%20");
        String disposition = "attachment; filename=\"" + safe + "\"; filename*=UTF-8''" + encoded;
        getReqBuilder.responseContentDisposition(disposition);
      } else {
        getReqBuilder.responseContentDisposition("attachment");
      }

      if (contentType != null && contentType.length() > 0) {
        getReqBuilder.responseContentType(contentType);
      }

      GetObjectPresignRequest presignRequest = GetObjectPresignRequest.builder().signatureDuration(expires)
          .getObjectRequest(getReqBuilder.build()).build();

      PresignedGetObjectRequest presigned = presigner.presignGetObject(presignRequest);
      return presigned.url().toString();

    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }

  // -------------------------
  // Client / Presigner builders
  // -------------------------
  public static S3Client buildClient() {
    S3ClientBuilder builder = S3Client.builder();

    Region region = Region.of(regionName);
    builder.region(region);

    AwsCredentialsProvider credentialsProvider = resolveCredentialsProvider();

    return builder.credentialsProvider(credentialsProvider).build();
  }

  public static S3Presigner buildPresigner() {
    return buildPresigner(regionName);
  }

  public static S3Presigner buildPresigner(String regionName) {
    Region region = Region.of(regionName);
    AwsCredentialsProvider credentialsProvider = resolveCredentialsProvider();

    return S3Presigner.builder().region(region).credentialsProvider(credentialsProvider).build();
  }

  private static AwsCredentialsProvider resolveCredentialsProvider() {
    AwsCredentialsProvider credentialsProvider;
    if (accessKeyId != null && secretAccessKey != null) {
      AwsBasicCredentials awsCreds = AwsBasicCredentials.create(accessKeyId, secretAccessKey);
      credentialsProvider = StaticCredentialsProvider.create(awsCreds);
    } else if (AWS_PROFILE != null) {
      credentialsProvider = ProfileCredentialsProvider.create(AWS_PROFILE);
    } else {
      credentialsProvider = DefaultCredentialsProvider.create();
    }
    return credentialsProvider;
  }

  public static String getBucketName() {
    return bucketName;
  }

  public static String getRegionName() {
    return regionName;
  }

}

配置类 AwsS3Config

测试工具类 AwsS3UtilsTest

创建一个测试类，用于验证 S3 上传功能。

package nexus.io.tio.boot.admin.utils;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

import org.junit.Test;

import nexus.io.tio.boot.admin.config.AwsS3Config;
import nexus.io.tio.utils.environment.EnvUtils;

import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.PutObjectResponse;

public class AwsS3UtilsTest {

  @Test
  public void test() throws IOException {
    EnvUtils.load();

    Path path = java.nio.file.Paths.get("F:\\my_file\\my_photo\\kitty\\kitty-cat.jpg");

    byte[] fileContent = Files.readAllBytes(path);

    String targetName = "001.jpg"; // 上传到S3的文件名
    String suffix = "jpg";

    // 示例使用upload方法
    try (S3Client client = new AwsS3Config().buildClient();) {
      PutObjectResponse response = AwsS3Utils.upload(client, AwsS3Utils.bucketName, targetName, fileContent, suffix);
      String url = String.format(AwsS3Utils.urlFormat, AwsS3Utils.bucketName, targetName);
      System.out.println(url);
      System.out.println(response.eTag());
    }
  }

}

实现文件上传服务 AwsS3StorageService

创建一个服务类，处理文件的上传及相关信息的保存到数据库。

package nexus.io.tio.boot.admin.services.storage;

import com.jfinal.kit.Kv;
import com.jfinal.kit.StrKit;
import nexus.io.db.TableInput;
import nexus.io.db.TableResult;
import nexus.io.db.activerecord.Row;
import nexus.io.jfinal.aop.Aop;
import nexus.io.model.body.RespBodyVo;
import nexus.io.model.upload.UploadFile;
import nexus.io.model.upload.UploadResult;
import nexus.io.table.services.ApiTable;
import nexus.io.tio.boot.admin.consts.StoragePlatformConst;
import nexus.io.tio.boot.admin.costants.TioBootAdminTableNames;
import nexus.io.tio.boot.admin.dao.SystemUploadFileDao;
import nexus.io.tio.boot.admin.services.StorageService;
import nexus.io.tio.boot.admin.services.system.SystemUploadFileService;
import nexus.io.tio.boot.admin.utils.storage.AwsS3Utils;
import nexus.io.tio.utils.crypto.Md5Utils;
import nexus.io.tio.utils.hutool.FilenameUtils;
import nexus.io.tio.utils.snowflake.SnowflakeIdUtils;

import lombok.extern.slf4j.Slf4j;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.PutObjectResponse;

@Slf4j
public class AwsS3StorageService implements StorageService {
  @Override
  public RespBodyVo upload(UploadFile uploadFile) {
    return upload(DEFAULT_CATEGORY, uploadFile);
  }

  public RespBodyVo upload(String category, UploadFile uploadFile) {
    if (StrKit.isBlank(category)) {
      category = DEFAULT_CATEGORY;
    }
    UploadResult uploadResultVo = uploadFile(category, uploadFile);

    return RespBodyVo.ok(uploadResultVo);
  }

  public UploadResult uploadFile(String category, UploadFile uploadFile) {
    long id = SnowflakeIdUtils.id();
    return uploadFile(category, uploadFile, id);
  }

  public UploadResult uploadFile(String category, UploadFile uploadFile, Long id) {
    // 上传文件
    String name = uploadFile.getName();
    String suffix = FilenameUtils.getSuffix(name);
    String newFilename = id + "." + suffix;
    String targetName = category + "/" + newFilename;
    return uploadFile(id, targetName, uploadFile, suffix);
  }

  /**
   * @param id
   * @param originFilename
   * @param targetName
   * @param fileContent
   * @param size
   * @param suffix
   * @return
   */
  public UploadResult uploadFile(long id, String targetName, UploadFile uploadFile, String suffix) {
    String name = uploadFile.getName();
    long size = uploadFile.getSize();
    byte[] fileContent = uploadFile.getData();

    String md5 = Md5Utils.md5Hex(fileContent);
    Row record = Aop.get(SystemUploadFileDao.class).getFileBasicInfoByMd5(md5);
    if (record != null) {
      log.info("select table reuslt:{}", record.toMap());
      id = record.getLong("id");
      String url = this.getUrl(record.getStr("bucket_name"), record.getStr("target_name"));
      Kv kv = record.toKv();
      kv.remove("target_name");
      kv.remove("bucket_name");
      kv.set("url", url);
      kv.set("md5", md5);
      return new UploadResult(id, name, size, url, md5);
    } else {
      log.info("not found from cache table:{}", md5);
    }

    String etag = null;
    try (S3Client client = AwsS3Utils.buildClient();) {
      PutObjectResponse response = AwsS3Utils.upload(client, AwsS3Utils.bucketName, targetName, fileContent, suffix);
      etag = response.eTag();
    } catch (Exception e) {
      log.error("Error uploading file", e);
      throw new RuntimeException(e);
    }

    // Log and save to database
    log.info("Uploaded with ETag: {}", etag);

    TableInput kv = TableInput.create().set("name", name).set("size", size).set("md5", md5)
        //
        .set("platform", StoragePlatformConst.aws_s3).set("region_name", AwsS3Utils.regionName)
        .set("bucket_name", AwsS3Utils.bucketName)
        //
        .set("target_name", targetName).set("file_id", etag);

    TableResult<Kv> save = ApiTable.save(TioBootAdminTableNames.tio_boot_admin_system_upload_file, kv);
    String downloadUrl = getUrl(AwsS3Utils.bucketName, targetName);

    return new UploadResult(save.getData().getLong("id"), name, Long.valueOf(size), downloadUrl, md5);

  }

  @Override
  public String getUrl(String bucketName, String targetName) {
    return AwsS3Utils.getUrl(bucketName, targetName);
  }

  @Override
  public String getUrl(String targetName) {
    return AwsS3Utils.getUrl(targetName);
  }

  @Override
  public UploadResult getUrlById(String id) {
    return Aop.get(SystemUploadFileService.class).getUrlById(id);
  }

  @Override
  public UploadResult getUrlById(long id) {
    return Aop.get(SystemUploadFileService.class).getUrlById(id);
  }

  @Override
  public UploadResult getUrlByMd5(String md5) {
    return Aop.get(SystemUploadFileService.class).getUrlByMd5(md5);
  }

  @Override
  public String getPresignedDownloadUrl(String targetName) {

    return AwsS3Utils.getPresignedDownloadUrl(targetName);
  }

  @Override
  public String getPresignedDownloadUrl(String bucket, String targetName) {
    return AwsS3Utils.getPresignedDownloadUrl(bucket, targetName);
  }

  @Override
  public String getPresignedDownloadUrl(String region, String bucket, String targetName) {
    return AwsS3Utils.getPresignedDownloadUrl(region, bucket, targetName);
  }

  @Override
  public UploadResult getPresignedDownloadUrl(Long id) {
    return Aop.get(SystemUploadFileService.class).getPresignedDownloadUrl(id);
  }

}

添加 Handler 以接收上传文件

创建一个处理上传请求的 Handler 类，用于接收文件并调用上传服务。

package nexus.io.tio.boot.admin.handler.system;

import java.util.Map;

import com.jfinal.kit.Kv;
import com.jfinal.kit.StrKit;
import nexus.io.db.TableInput;
import nexus.io.db.TableResult;
import nexus.io.db.activerecord.Row;
import nexus.io.jfinal.aop.Aop;
import nexus.io.model.body.RespBodyVo;
import nexus.io.model.upload.UploadFile;
import nexus.io.model.upload.UploadResult;
import nexus.io.table.services.ApiTable;
import nexus.io.table.utils.TableInputUtils;
import nexus.io.table.utils.TableResultUtils;
import nexus.io.tio.boot.admin.costants.TioBootAdminTableNames;
import nexus.io.tio.boot.admin.services.storage.AwsS3StorageService;
import nexus.io.tio.boot.http.TioRequestContext;
import nexus.io.tio.boot.utils.TioRequestParamUtils;
import nexus.io.tio.http.common.HttpRequest;
import nexus.io.tio.http.common.HttpResponse;
import nexus.io.tio.http.server.model.HttpCors;
import nexus.io.tio.http.server.util.CORSUtils;
import nexus.io.tio.http.server.util.Resps;

public class SystemFileAwsS3Handler {
  AwsS3StorageService storageService = Aop.get(AwsS3StorageService.class);

  public HttpResponse upload(HttpRequest request) throws Exception {
    HttpResponse httpResponse = TioRequestContext.getResponse();
    CORSUtils.enableCORS(httpResponse, new HttpCors());
    UploadFile uploadFile = request.getUploadFile("file");
    String category = request.getParam("category");

    if (uploadFile != null) {
      RespBodyVo RespBodyVo = storageService.upload(category, uploadFile);
      return Resps.json(httpResponse, RespBodyVo);
    }
    return Resps.json(httpResponse, RespBodyVo.ok("Fail"));
  }

  public HttpResponse getUploadRecordByMd5(HttpRequest request) throws Exception {
    HttpResponse httpResponse = TioRequestContext.getResponse();
    CORSUtils.enableCORS(httpResponse, new HttpCors());

    Map<String, Object> map = TioRequestParamUtils.getRequestMap(request);
    TableInput kv = TableInputUtils.camelToUnderscore(map);
    // 调用ApiTable查询数据
    TableResult<Row> jsonBean = ApiTable.get(TioBootAdminTableNames.tio_boot_admin_system_upload_file, kv);
    TableResult<Kv> TableResult = TableResultUtils.recordToKv(jsonBean);

    return Resps.json(httpResponse,
        RespBodyVo.ok(TableResult.getData()).code(TableResult.getCode()).msg(TableResult.getMsg()));
  }

  public HttpResponse getUrl(HttpRequest request) throws Exception {
    HttpResponse httpResponse = TioRequestContext.getResponse();
    CORSUtils.enableCORS(httpResponse, new HttpCors());

    RespBodyVo respBodyVo = null;
    String id = request.getParam("id");

    String md5 = request.getParam("md5");
    if (StrKit.notBlank(id)) {
      // id,md5,name,url,
      UploadResult uploadResultVo = storageService.getUrlById(id);
      if (uploadResultVo == null) {
        respBodyVo = RespBodyVo.fail();
      } else {
        respBodyVo = RespBodyVo.ok(uploadResultVo);
      }

    } else if (StrKit.notBlank(md5)) {
      UploadResult uploadResultVo = storageService.getUrlByMd5(md5);
      if (uploadResultVo == null) {
        respBodyVo = RespBodyVo.fail();
      } else {
        respBodyVo = RespBodyVo.ok(uploadResultVo);
      }
    } else {
      respBodyVo = RespBodyVo.fail("id or md5 can not be empty");
    }

    return Resps.json(httpResponse, respBodyVo);
  }
}

配置路由

在路由配置文件中添加相应的路由，指向 SystemFileAwsS3Handler 的方法。

SystemFileAwsS3Handler systemFileAwsS3Handler = Aop.get(SystemFileAwsS3Handler.class);

r.add("/api/system/file/s3/upload", systemFileAwsS3Handler::upload);
r.add("/api/system/file/s3/md5", systemFileAwsS3Handler::getUploadRecordByMd5);
r.add("/api/system/file/s3/url", systemFileAwsS3Handler::getUrl);

测试上传功能

测试上传请求

使用 curl 命令发送一个 POST 请求，将文件上传到 S3。

curl --location --request POST 'http://localhost:8100/tio-boot-admin/api/system/file/upload/s3' \
--header 'authorization: 123456' \
--header 'Content-Type: multipart/form-data; boundary=--------------------------946279255222128586808179' \
--header 'Cookie: PHPSESSID=f1aa9dbe6c8e4d06aa5bc59d3b7b43b2' \
--form 'file=@"F:\\my_file\\my_photo\\aliyun\\配置.png"' \
--form 'category="sjsu/professor"'

返回数据示例

成功上传文件后，服务器将返回如下 JSON 数据：

{
  "code": 1,
  "data": {
    "id": "394502029835268096",
    "url": "https://rumiapp.s3.us-west-1.amazonaws.com/sjsu/professor/394502024734994432.png"
  },
  "ok": true
}
  • id: 文件在数据库中的唯一标识。
  • url: 文件在 S3 上的访问地址。

总结

本文详细介绍了如何在 AWS S3 上配置存储桶，并将其集成到 Tio-Boot 项目中，实现文件的上传和存储。通过配置存储桶的公开权限、获取访问密钥、添加必要的依赖及代码实现，您可以轻松地将文件存储到 AWS S3 并在应用中进行管理。请确保在公开存储桶时充分了解相关的安全风险，并采取必要的安全措施以保护您的数据。

如果在配置或集成过程中遇到问题，请参考 AWS 官方文档 或相关开发文档获取更多帮助。