diff --git a/README.md b/README.md
index 12e4c448..631a3c7c 100644
--- a/README.md
+++ b/README.md
@@ -44,6 +44,8 @@ Amazon S3、GoogleCloud Storage、FastDFS、 Azure Blob Storage、Cloudflare R2
 
 💡 通过 WebDAV 连接到 Alist 后，可以使用百度网盘、天翼云盘、阿里云盘、迅雷网盘等常见存储服务，查看 [Alist 支持的存储平台](https://alist.nn.ci/zh/guide/webdav.html#webdav-%E5%AD%98%E5%82%A8%E6%94%AF%E6%8C%81)
 
+🚚 支持在不同存储平台之间迁移文件，详情查看 [迁移文件](https://x-file-storage.xuyanwu.cn/#/迁移文件)
+
 GitHub：https://github.com/dromara/x-file-storage
 <br />
 Gitee：https://gitee.com/dromara/x-file-storage
@@ -54,6 +56,8 @@ Gitee：https://gitee.com/dromara/x-file-storage
 
 这里是简要的更新记录，查看 [详细的更新记录](https://x-file-storage.xuyanwu.cn/#/更新记录)
 
+`2.2.0` 修复大量问题，新增获取文件、列举文件，重构预签名 URL 支持客户端上传、下载、删除等操作，新增 Solon 插件，优化手动分片上传等功能，详情查看 [更新记录](https://x-file-storage.xuyanwu.cn/#/更新记录?id=_220)
+<br />
 `2.1.0` 修复大量问题，新增存储平台 FastDFS 和 Azure Blob Storage，新增复制、移动（重命名）文件，手动分片上传（断点续传）和计算哈希等功能，详情查看 [更新记录](https://x-file-storage.xuyanwu.cn/#/更新记录?id=_210)
 <br />
 `2.0.0` 捐赠至 [dromara](https://dromara.org/zh) 开源社区，更改项目名、包名，优化项目结构、支持 Metadata 元数据等，从旧版升级需要注意，详情查看 [更新记录](https://x-file-storage.xuyanwu.cn/#/更新记录?id=_200)
@@ -71,11 +75,13 @@ Gitee：https://gitee.com/dromara/x-file-storage
 ### 📅更新计划
 
 - 接入存储平台：HDFS、火山云 TOS、Samba、NFS
-- 用户端直传
 - 追加缩略图
-- 列出文件
 - 文件内容预加载
 - 新增 Access 模块，尝试通过 HTTP、FTP、WebDAV 等协议对外提供接口，方便其它程序使用
+- 追加文件
+- 分片下载
+- 直接输出到 HttpServletResponse 的响应流中
+- 其它更多功能
 
 -------
 
@@ -85,14 +91,14 @@ Gitee：https://gitee.com/dromara/x-file-storage
 
 #### 🔧 配置
 
-这里以阿里云 OSS 为例，`pom.xml` 引入本项目，这里默认是 `SpringBoot` 环境，其它环境参考 [脱离 SpringBoot 单独使用](https://x-file-storage.xuyanwu.cn/#/脱离SpringBoot单独使用)
+这里以阿里云 OSS 为例，`pom.xml` 引入本项目，这里默认是 `SpringBoot` 环境，`Solon` 环境参考 [在 Solon 中使用](https://x-file-storage.xuyanwu.cn/#/在Solon中使用)，其它环境参考 [脱离 SpringBoot 单独使用](https://x-file-storage.xuyanwu.cn/#/脱离SpringBoot单独使用)
 
 ```xml
 <!-- 引入本项目 -->
 <dependency>
     <groupId>org.dromara.x-file-storage</groupId>
     <artifactId>x-file-storage-spring</artifactId>
-    <version>2.1.0</version>
+    <version>2.2.0</version>
 </dependency>
 <!-- 引入 阿里云 OSS SDK，如果使用其它存储平台，就引入对应的 SDK  -->
 <dependency>
@@ -138,7 +144,7 @@ public class SpringFileStorageTestApplication {
 ```
  #### ✨开始上传
 
- 支持 File、MultipartFile、byte[]、InputStream、URL、URI、String、HttpServletRequest，大文件会自动分片上传。如果想支持更多方式，请阅读 [文件适配器](https://x-file-storage.xuyanwu.cn/#/文件适配器) 章节
+ 支持 File、MultipartFile、UploadedFile、byte[]、InputStream、URL、URI、String、HttpServletRequest，大文件会自动分片上传。如果想支持更多方式，请阅读 [文件适配器](https://x-file-storage.xuyanwu.cn/#/文件适配器) 章节
 
 ```java
 @RestController
@@ -163,6 +169,7 @@ public class FileDetailController {
     public String upload2(MultipartFile file) {
         FileInfo fileInfo = fileStorageService.of(file)
                 .setPath("upload/") //保存到相对路径下，为了方便管理，不需要可以不写
+                .setSaveFilename("image.jpg") //设置保存的文件名，不需要可以不写，会随机生成
                 .setObjectId("0")   //关联对象id，为了方便管理，不需要可以不写
                 .setObjectType("0") //关联对象类型，为了方便管理，不需要可以不写
                 .putAttr("role","admin") //保存一些属性，可以在切面、保存上传记录、自定义存储平台等地方获取使用，不需要可以不写
diff --git a/docs/Metadata.md b/docs/Metadata.md
index 90c0260b..106b0352 100644
--- a/docs/Metadata.md
+++ b/docs/Metadata.md
@@ -18,12 +18,22 @@ FileInfo fileInfo = fileStorageService.of(file)
         .putThUserMetadata("role","777")
         .thumbnail()
         .upload();
+
+//获取
+RemoteFileInfo info = fileStorageService.getFile(fileInfo);
+Assert.notNull(info, "文件不存在");
+//文件元数据
+MapProxy metadata = info.getKebabCaseInsensitiveMetadata();
+//文件用户元数据
+MapProxy userMetadata = info.getKebabCaseInsensitiveUserMetadata();
 ```
 
 > [!WARNING|label:重要提示：]
 > 每个存储平台支持的 Metadata 有所不同，例如 七牛云 Kodo 和 又拍云 USS 就不支持 `Content-Disposition`，具体支持情况以每个存储平台的官方文档为准
 >
 > 在传入 UserMetadata 时，不用传入前缀，例如 `x-amz-meta-` `x-qn-meta-` `x-upyun-meta-`，SDK会自动处理
+>
+> 每个存储平台获取到的 Metadata 都不相同，有些是字符串类型，有些是其它类型的对象，这部分需要自行做好判断
 
 
 ## 处理异常
diff --git a/docs/README.md b/docs/README.md
index 0455ea33..101cdd2d 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -45,6 +45,8 @@ Amazon S3、GoogleCloud Storage、FastDFS、 Azure Blob Storage、Cloudflare R2
 
 💡 通过 WebDAV 连接到 Alist 后，可以使用百度网盘、天翼云盘、阿里云盘、迅雷网盘等常见存储服务，查看 [Alist 支持的存储平台](https://alist.nn.ci/zh/guide/webdav.html#webdav-%E5%AD%98%E5%82%A8%E6%94%AF%E6%8C%81)
 
+🚚 支持在不同存储平台之间迁移文件，详情查看 [迁移文件](迁移文件)
+
 GitHub：https://github.com/dromara/x-file-storage
 <br />
 Gitee：https://gitee.com/dromara/x-file-storage
@@ -55,6 +57,8 @@ Gitee：https://gitee.com/dromara/x-file-storage
 
 这里是简要的更新记录，查看 [详细的更新记录](更新记录)
 
+`2.2.0` 修复大量问题，新增获取文件、列举文件，重构预签名 URL 支持客户端上传、下载、删除等操作，新增 Solon 插件，优化手动分片上传等功能，详情查看 [更新记录](更新记录?id=_220)
+<br />
 `2.1.0` 修复大量问题，新增存储平台 FastDFS 和 Azure Blob Storage，新增复制、移动（重命名）文件，手动分片上传（断点续传）和计算哈希等功能，详情查看 [更新记录](更新记录?id=_210)
 <br />
 `2.0.0` 捐赠至 [dromara](https://dromara.org/zh) 开源社区，更改项目名、包名，优化项目结构、支持 Metadata 元数据等，从旧版升级需要注意，详情查看 [更新记录](更新记录?id=_200)
@@ -72,11 +76,13 @@ Gitee：https://gitee.com/dromara/x-file-storage
 # 📅更新计划
 
 - 接入存储平台：HDFS、火山云 TOS、Samba、NFS
-- 用户端直传
 - 追加缩略图
-- 列出文件
 - 文件内容预加载
 - 新增 Access 模块，尝试通过 HTTP、FTP、WebDAV 等协议对外提供接口，方便其它程序使用
+- 追加文件
+- 分片下载
+- 直接输出到 HttpServletResponse 的响应流中
+- 其它更多功能
 
 -------
 
@@ -86,6 +92,32 @@ Gitee：https://gitee.com/dromara/x-file-storage
 
 -------
 
+# 💳捐赠
+如果你觉得这个项目不错，可以点个 Star 或捐赠请作者吃包辣条~，不想打赏的话用支付宝扫最后一个码可以领取个红包，在此表示感谢^_^
+
+<img src="https://x-file-storage.xuyanwu.cn/assets/wx.png" style="height: 350px;margin-right: 20px" alt="微信">
+<img src="https://x-file-storage.xuyanwu.cn/assets/zfb.jpg" style="height: 350px;margin-right: 20px" alt="支付宝">
+<img src="https://x-file-storage.xuyanwu.cn/assets/zfb2.jpg" style="height: 350px" alt="支付宝2">
+<img src="https://x-file-storage.xuyanwu.cn/assets/elm.jpg" style="height: 350px;margin-right: 20px" alt="饿了么">
+<img src="https://x-file-storage.xuyanwu.cn/assets/mt.jpeg" style="height: 350px" alt="美团外卖">
+
+或者点击以下链接，将页面拉到最下方点击“捐赠”即可
+
+[Gitee上捐赠](https://gitee.com/dromara/x-file-storage)
+
+-------
+
+# 🌶️VIP交流群
+
+扫描上方二维码捐赠 99 元，截图发我 `QQ1171736840` 即可加入 VIP 交流群（超过一年则需要再次捐赠，否则将进行清退）
+
+也可以点击添加免费交流群
+<a target="_blank" href='https://jq.qq.com/?_wv=1027&k=eGfeNqka'>
+<img src='https://img.shields.io/badge/QQ%E7%BE%A4-515706495-orange' alt='515706495' />
+</a> 一起交流
+
+-------
+
 # 🏗️添砖加瓦
 
 ## 🎋分支说明
@@ -134,36 +166,10 @@ X File Storage 感谢各位小伙伴的信任与支持，如果您已经在项
 [在 Gitee 上登记](https://gitee.com/dromara/x-file-storage/issues/I83Q6R)<br/>
 [在 GitHub 上登记](https://github.com/dromara/x-file-storage/issues/114)
 
-[tg.md](https://x-file-storage.xuyanwu.cn/assets/link/member-project.md ':include')
-
 -------
 
 # 🌏知识星球
 
 <img src="https://x-file-storage.xuyanwu.cn/assets/zsxq.png" height="200px" alt="知识星球">
 
--------
-
-# 💳捐赠
-如果你觉得这个项目不错，可以点个 Star 或捐赠请作者吃包辣条~，不想打赏的话用支付宝扫最后一个码可以领取个红包，在此表示感谢^_^
-
-<img src="https://x-file-storage.xuyanwu.cn/assets/wx.png" style="height: 350px;margin-right: 20px" alt="微信">
-<img src="https://x-file-storage.xuyanwu.cn/assets/zfb.jpg" style="height: 350px;margin-right: 20px" alt="支付宝">
-<img src="https://x-file-storage.xuyanwu.cn/assets/zfb2.jpg" style="height: 350px;margin-right: 20px" alt="支付宝2">
-<img src="https://x-file-storage.xuyanwu.cn/assets/elm.jpg" style="height: 350px;margin-right: 20px" alt="饿了么">
-<img src="https://x-file-storage.xuyanwu.cn/assets/mt.jpeg" style="height: 350px" alt="美团外卖">
-
-或者点击以下链接，将页面拉到最下方点击“捐赠”即可
-
-[Gitee上捐赠](https://gitee.com/dromara/x-file-storage)
-
--------
-
-# 🌶️VIP交流群
-
-扫描上方二维码捐赠 99 元，截图发我 `QQ1171736840` 即可加入 VIP 交流群（超过一年则需要再次捐赠，否则将进行清退）
-
-也可以点击添加免费交流群
-<a target="_blank" href='https://jq.qq.com/?_wv=1027&k=eGfeNqka'>
-<img src='https://img.shields.io/badge/QQ%E7%BE%A4-515706495-orange' alt='515706495' />
-</a> 一起交流
+[member-project.md](https://x-file-storage.xuyanwu.cn/assets/link/member-project.md ':include')
diff --git a/docs/_navbar.md b/docs/_navbar.md
index 42a7ab40..10503e49 100644
--- a/docs/_navbar.md
+++ b/docs/_navbar.md
@@ -1,5 +1,6 @@
-* 🌟文档版本 2.1.0
+* 🌟文档版本 2.2.0
 
+  * [2.2.0](https://x-file-storage.xuyanwu.cn/2.2.0/)
   * [2.1.0](https://x-file-storage.xuyanwu.cn/2.1.0/)
   * [2.0.0](https://x-file-storage.xuyanwu.cn/2.0.0/)
   * [1.0.3](https://x-file-storage.xuyanwu.cn/1.0.3/)
diff --git a/docs/_sidebar.md b/docs/_sidebar.md
index 5ddd343f..c1fa29f0 100644
--- a/docs/_sidebar.md
+++ b/docs/_sidebar.md
@@ -1,8 +1,9 @@
 * [📚简介](/ "简介")
 * [🍭快速入门](快速入门 "快速入门")
 * [🍬基础功能](基础功能 "基础功能")
+* [🚚迁移文件](迁移文件 "迁移文件")
 * [🍉ACL 访问控制列表](acl "ACL 访问控制列表")
-* [🥑预签名 URL](预签名URL "签名 URL")
+* [🥑预签名 URL](预签名URL "预签名 URL")
 * [🌼Metadata 元数据](Metadata "Metadata 元数据")
 * [🥦存储平台](存储平台 "存储平台")
 * [🌽文件适配器](文件适配器 "文件适配器")
@@ -10,5 +11,6 @@
 * [🍵️计算哈希](hash "hash")
 * [🧪切面](切面 "切面")
 * [🌱脱离 SpringBoot 单独使用](脱离SpringBoot单独使用 "脱离 SpringBoot 单独使用")
+* [🍩在 Solon 中使用](在Solon中使用 "在 Solon 中使用")
 * [🙋‍♂️常见问题](常见问题 "常见问题")
 * [📜更新记录](更新记录 "更新记录")
diff --git a/docs/index.html b/docs/index.html
index 07fafca5..d8deb6fb 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -10,6 +10,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0">
     <link rel="icon" href="https://x-file-storage.xuyanwu.cn//assets/logo4.png" type="image/x-icon"/>
     <link rel="stylesheet" href="https://x-file-storage.xuyanwu.cn/assets/docsify-theme-vue.css">
+    <link rel="stylesheet" href="https://x-file-storage.xuyanwu.cn/assets/nav.css">
     <style>
         #main {
             max-width: 90%;
diff --git "a/docs/\345\234\250Solon\344\270\255\344\275\277\347\224\250.md" "b/docs/\345\234\250Solon\344\270\255\344\275\277\347\224\250.md"
new file mode 100644
index 00000000..997cac78
--- /dev/null
+++ "b/docs/\345\234\250Solon\344\270\255\344\275\277\347\224\250.md"
@@ -0,0 +1,66 @@
+# 在 Solon 中使用
+
+> Solon 官网 https://solon.noear.org/
+
+从 `2.2.0` 版本开始原生支持在 `Solon` 中使用，之前的版本可以参考 [脱离 SpringBoot 单独使用](脱离SpringBoot单独使用)
+
+先引入本项目, 注意这里是 `x-file-storage-solon`，而不是 `x-file-storage-core`，之后再参考 [快速入门](快速入门) 引入对应平台的依赖
+
+```xml
+<dependency>
+    <groupId>org.dromara.x-file-storage</groupId>
+    <artifactId>x-file-storage-solon</artifactId>
+    <version>2.2.0</version>
+</dependency>
+```
+
+如果使用本地存储, 请务必添加 `solon.web.staticfiles` 依赖
+```xml
+<dependency>
+    <groupId>org.noear</groupId>
+    <artifactId>solon.web.staticfiles</artifactId>
+    <version>2.7.1</version><!-- 当前行可去掉, 跟随 solon 的版本管理 -->
+</dependency>
+```
+
+
+默认情况下，Solon 会自动装配 `SolonFileStorageProperties` , 文件配置完全等同于使用 Spring 的情况, 可以在 `app.yml` 中按照 Spring 配置文件的格式进行配置。
+如:
+```yaml
+dromara:
+  x-file-storage: #文件存储配置
+    default-platform: minio-user #默认使用的存储平台
+    thumbnail-suffix: ".min.jpg" #缩略图后缀，例如【.min.jpg】【.png】
+    enable-multipart-file-wrapper: true #是否启用多文件包装器
+    local-plus:
+      - platform: local-plus-1 # 存储平台标识
+        enable-storage: true  #启用存储
+        enable-access: true #启用访问（线上请使用 Nginx 配置，效率更高）
+        domain: http://127.0.0.1:8080/file/ # 访问域名，例如：“http://127.0.0.1:8030/file/”，注意后面要和 path-patterns 保持一致，“/”结尾，本地存储建议使用相对路径，方便后期更换域名
+        base-path: local-plus/ # 基础路径
+        path-patterns: /file/ # 访问路径
+        storage-path: D:/temp/ # 存储路径
+    minio:
+      - platform: minio-user # 存储平台标识
+        enable-storage: true  # 启用存储
+        access-key: j9rMyECcmNH0lNBqPfOo
+        secret-key: 0NYFJSl4D8msuxHirenthXA4lvju4c3QNdmQ29Ob
+        end-point: http://127.0.0.1:9000
+        bucket-name: user
+        #        domain: ?? # 访问域名，注意“/”结尾，例如：http://minio.abc.com/abc/
+        base-path: user/ # 基础路径
+      - platform: minio-dept # 存储平台标识
+        enable-storage: true  # 启用存储
+        access-key: j9rMyECcmNH0lNBqPfOo
+        secret-key: 0NYFJSl4D8msuxHirenthXA4lvju4c3QNdmQ29Ob
+        end-point: http://127.0.0.1:9000
+        bucket-name: dept
+        #        domain: ?? # 访问域名，注意“/”结尾，例如：http://minio.abc.com/abc/
+        base-path: dept/ # 基础路径
+```
+
+同时, 由于 Solon 和 Spring 环境不一致, 部分功能使用会有差异, 详情参见 [Solon 与 Spring Boot 的区别](https://solon.noear.org/article/compare-springboot)
+
+在注入 `fileStorageService` 后, 可以使用 `fileStorageService` 进行文件操作, 例如上传、下载、删除等。完全等同 Spring 的使用方式。
+
+
diff --git "a/docs/\345\237\272\347\241\200\345\212\237\350\203\275.md" "b/docs/\345\237\272\347\241\200\345\212\237\350\203\275.md"
index e5b8f433..069ebbf4 100644
--- "a/docs/\345\237\272\347\241\200\345\212\237\350\203\275.md"
+++ "b/docs/\345\237\272\347\241\200\345\212\237\350\203\275.md"
@@ -4,7 +4,7 @@
 
 ### 基本的上传方式
 
-`of`方法支持 File、MultipartFile、byte[]、InputStream、URL、URI、String、HttpServletRequest，大文件会自动分片上传。如果想支持更多方式，请阅读 [文件适配器](文件适配器) 章节
+`of`方法支持 File、MultipartFile、UploadedFile、byte[]、InputStream、URL、URI、String、HttpServletRequest，大文件会自动分片上传。如果想支持更多方式，请阅读 [文件适配器](文件适配器) 章节
 
 ```java
 // 直接上传
@@ -223,6 +223,10 @@ fileStorageService.abortMultipartUpload(fileInfo).abort();
 > 2. 建议将 FileInfo 保存到数据库中，这样就可以使用 `fileStorageService.getFileInfoByUrl("https://abc.def.com/xxx.png")` 来获取 FileInfo 方便操作，详情请阅读 [保存上传记录](基础功能?id=保存上传记录) 章节
 > 3. 手动分片上传暂时无法生成缩略图，将在后续版本提供追加缩略图功能。
 
+###  客户端上传
+
+通过预签名 URL 的方式可以实现客户端上传，详情查看 [预签名 URL 上传](预签名URL?id=上传)
+
 
 ### 监听上传进度
 
@@ -526,6 +530,64 @@ CREATE TABLE `file_part_detail`
 
 <!-- fold:end -->
 
+## 获取文件
+
+```java
+//通过 FileInfo 获取文件信息
+RemoteFileInfo info = fileStorageService.getFile(fileInfo);
+//通过 FileInfo 获取缩略图文件信息
+RemoteFileInfo info2 = fileStorageService.getThFile(fileInfo);
+
+//将结果转成 FileInfo 方便进行其它操作
+FileInfo fileInfo2 = info.toFileInfo();
+//将缩略图文件信息也 set 到 FileInfo 中
+info2.toFileInfoTh(fileInfo2);
+
+//自行传入 path 及 filename 获取文件信息
+RemoteFileInfo info3 = fileStorageService.getFile().setPath("test/").setFilename("123.jpg").getFile();
+Assert.notNull(info3, "文件不存在");
+log.info("获取文件结果：{}", info3);
+//文件元数据
+MapProxy metadata = info3.getKebabCaseInsensitiveMetadata();
+//文件用户元数据
+MapProxy userMetadata = info3.getKebabCaseInsensitiveUserMetadata();
+
+//获取原始文件信息，这里以阿里云为例
+OSSObject ossObject = info3.getOriginalAliyunOssObject();
+```
+
+> [!WARNING|label:重要提示：]
+> 将 RemoteFileInfo 转为 FileInfo 时，有以下几点需要注意：
+> 1. 一般情况下 FileInfo 中的 createTime（创建时间）就是 RemoteFileInfo 中的 lastModified（最后修改时间），如果有误，可以自行设置
+> 2. RemoteFileInfo 中的 metadata 元数据值为 Object 类型，FileInfo 中的元数据值为 String 类型，目前是将 Object 类型使用 toString() 方法转为 String 类型，应该可以满足大部分情况，如有需要可以自行转换
+
+## 列举文件
+
+```java
+//是否支持列举文件
+ListFilesSupportInfo isSupportListFiles = fileStorageService.isSupportListFiles();
+
+//列举文件及目录
+ListFilesResult result = fileStorageService.listFiles().setPath("test/").listFiles();
+result.getDirList().forEach(info -> log.info("目录：{}", info));
+log.info("列举目录完成，共 {} 个目录", result.getDirList().size());
+result.getFileList().forEach(info -> log.info("文件：{}", info));
+log.info("列举文件完成，共 {} 个文件", result.getFileList().size());
+log.info("列举文件全部结果：{}", result);
+
+//列表是否被截断，就是当前目录下还有其它文件或目录超出最大数量未被列举
+log.info("列表是否被截断：{}", result.getIsTruncated());
+log.info("下次列举的起始位置：{}", result.getNextMarker());
+
+//其它更多参数
+ListFilesResult result2 = fileStorageService.listFiles()
+        .setPath("test/") // 指定目录
+        .setMaxFiles(10) //要列举的最大文件及目录数量
+        .setFilenamePrefix("abc") // 文件名前缀
+        .setMarker("123456") //列举的起始位置，从上一次列举结果中获取
+        .listFiles();
+```
+
 ## 下载
 
 ### 多种下载方式
diff --git "a/docs/\345\255\230\345\202\250\345\271\263\345\217\260.md" "b/docs/\345\255\230\345\202\250\345\271\263\345\217\260.md"
index ab9be4d9..01c265ba 100644
--- "a/docs/\345\255\230\345\202\250\345\271\263\345\217\260.md"
+++ "b/docs/\345\255\230\345\202\250\345\271\263\345\217\260.md"
@@ -8,23 +8,23 @@
 > 1. 在使用复制功能时，如果同存储平台复制不支持，则会自动使用跨存储平台复制，内部是通过先下载再上传实现的，所有存储平台都支持，详情请阅读 [复制](基础功能?id=复制) 章节
 > 2. 在使用移动（重命名）功能时，如果同存储平台移动（重命名）不支持，则会自动使用跨存储平台移动（重命名），内部是通过先复制再删除源文件实现的，所有存储平台都支持，详情请阅读 [移动（重命名）](基础功能?id=移动（重命名）) 章节
 
-| 存储平台                | 上传 | 下载 | 删除 | 手动分片上传 | 预签名 URL | 同存储平台复制 | 同存储平台移动（重命名） | ACL 访问控制列表 | Metadata 元数据 | 兼容性说明                              |
-|---------------------|----|----|----|--------|---------|---------|--------------|------------|--------------|------------------------------------|
-| 本地                  | ✔️ | ✔️ | ✔️ | ✔️     | ❌       | ✔️      | ✔️           | ❌          | ❌            |                                    |
-| FTP                 | ✔️ | ✔️ | ✔️ | ❌      | ❌       | ❌       | ✔️           | ❌          | ❌            |                                    |
-| SFTP                | ✔️ | ✔️ | ✔️ | ❌      | ❌       | ❌       | ✔️           | ❌          | ❌            |                                    |
-| WebDAV              | ✔️ | ✔️ | ✔️ | ❌      | ❌       | ✔️      | ✔️           | ❌          | ❌            |                                    |
-| Amazon S3           | ✔️ | ✔️ | ✔️ | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
-| MinIO               | ✔️ | ✔️ | ✔️ | ✔️     | ✔️      | ✔️      | ❌            | ❌          | ✔️           |                                    |
-| 阿里云 OSS             | ✔️ | ✔️ | ✔️ | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
-| 华为云 OBS             | ✔️ | ✔️ | ✔️ | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
-| 腾讯云 COS             | ✔️ | ✔️ | ✔️ | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
-| 百度云 BOS             | ✔️ | ✔️ | ✔️ | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
-| 又拍云 USS             | ✔️ | ✔️ | ✔️ | ✔️     | ❌       | ✔️      | ✔️           | ❌          | ✔️           |                                    |
-| 七牛云 Kodo            | ✔️ | ✔️ | ✔️ | ✔️     | ✔️      | ✔️      | ✔️           | ❌          | ✔️           |                                    |
-| GoogleCloud Storage | ✔️ | ✔️ | ✔️ | ❌      | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
-| FastDFS             | ✔️ | ✔️ | ✔️ | ❌      | ❌       | ❌       | ❌            | ❌          | ✔️           | [查看](存储平台?id=OCI_FastDFS)          |
-| Azure Blob Storage  | ✔️ | ✔️ | ✔️ | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           | [查看](存储平台?id=OCI_AzureBlobStorage) |
+| 存储平台                | 上传 | 下载 | 删除 | 获取 | 列举文件 | 手动分片上传 | 预签名 URL | 同存储平台复制 | 同存储平台移动（重命名） | ACL 访问控制列表 | Metadata 元数据 | 兼容性说明                              |
+|---------------------|----|----|----|----|------|--------|---------|---------|--------------|------------|--------------|------------------------------------|
+| 本地                  | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ✔️     | ❌       | ✔️      | ✔️           | ❌          | ❌            |                                    |
+| FTP                 | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ❌      | ❌       | ❌       | ✔️           | ❌          | ❌            |                                    |
+| SFTP                | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ❌      | ❌       | ❌       | ✔️           | ❌          | ❌            |                                    |
+| WebDAV              | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ❌      | ❌       | ✔️      | ✔️           | ❌          | ❌            |                                    |
+| Amazon S3           | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
+| MinIO               | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ✔️     | ✔️      | ✔️      | ❌            | ❌          | ✔️           |                                    |
+| 阿里云 OSS             | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
+| 华为云 OBS             | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
+| 腾讯云 COS             | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
+| 百度云 BOS             | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
+| 又拍云 USS             | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ✔️     | ❌       | ✔️      | ✔️           | ❌          | ✔️           |                                    |
+| 七牛云 Kodo            | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ✔️     | ✔️      | ✔️      | ✔️           | ❌          | ✔️           |                                    |
+| GoogleCloud Storage | ✔️ | ✔️ | ✔️ | ✔️ | ✔️    | ✔️      | ✔️      | ✔️      | ❌            | ✔️         | ✔️           |                                    |
+| FastDFS             | ✔️ | ✔️ | ✔️ | ✔️ | ❌    | ❌      | ❌       | ❌       | ❌            | ❌          | ✔️           | [查看](存储平台?id=OCI_FastDFS)          |
+| Azure Blob Storage  | ✔️ | ✔️ | ✔️ | ✔️ | ✔️   | ✔️     | ✔️      | ✔️      | ❌            | ✔️         | ✔️           | [查看](存储平台?id=OCI_AzureBlobStorage) |
 
 对于兼容 Amazon S3 的存储平台，直接将配置写在 Amazon S3 中即可，具体兼容性见下图。
 
@@ -116,7 +116,7 @@ myStorage.close();//释放资源
 
 ```java
 @Bean
-public Object myFileStorageWebMvcConfigurer() {
+public WebMvcConfigurer myFileStorageWebMvcConfigurer() {
     return new WebMvcConfigurer() {
         @Override
         public void addResourceHandlers(@NonNull ResourceHandlerRegistry registry) {
@@ -872,6 +872,8 @@ boolean exists = fileStorageService.exists(fileInfo);
 byte[] bytes = fileStorageService.download(fileInfo).bytes();
 //删除
 fileStorageService.delete(fileInfo);
+//获取
+RemoteFileInfo info = fileStorageService.getFile(fileInfo);
 //其它更多操作
 ```
 
@@ -928,6 +930,8 @@ boolean exists = fileStorageService.exists(fileInfo);
 byte[] bytes = fileStorageService.download(fileInfo).bytes();
 //删除
 fileStorageService.delete(fileInfo);
+//获取
+RemoteFileInfo info = fileStorageService.getFile(fileInfo);
 //其它更多操作
 ```
 
@@ -947,7 +951,7 @@ fileStorageService.delete("http://192.168.1.121:8088/group1/M00/00/01/rBEgUGWd8C
 ```
 #### base-path 基础路径
 
-针对 `base-path` 参数，仅在上传成功时原样传到 FileInfo 中，可以用来保存到数据库中使用，实际上作用也不大，还会破坏 `url` 约定（url：实际上就是 domain + basePath + path + filename），详情见  [常见问题](常见问题?id=配置文件及-fileinfo-中各种路径（path）的区别？) 章节，所以强烈建议留空
+针对 `base-path` 参数，仅在上传成功时和获取文件时原样传到 FileInfo 及 RemoteFileInfo 中，可以用来保存到数据库中使用，实际上作用也不大，还会破坏 `url` 约定（url：实际上就是 domain + basePath + path + filename），详情见  [常见问题](常见问题?id=配置文件及-fileinfo-中各种路径（path）的区别？) 章节，所以强烈建议留空
 
 #### 缩略图文件名
 
diff --git "a/docs/\345\277\253\351\200\237\345\205\245\351\227\250.md" "b/docs/\345\277\253\351\200\237\345\205\245\351\227\250.md"
index c86ee98c..37b676d3 100644
--- "a/docs/\345\277\253\351\200\237\345\205\245\351\227\250.md"
+++ "b/docs/\345\277\253\351\200\237\345\205\245\351\227\250.md"
@@ -5,13 +5,13 @@
 > [!WARNING|label:重要提示：]
 > 如果是旧版本升级需要注意：从 2.0.0 版本开始，因为更换了项目名称及结构，导致依赖名称、配置文件参数名及包名与之前版本有所不同，详情查看 [更新记录](更新记录?id=_200)
 
-`pom.xml` 引入本项目，这里默认是 `SpringBoot` 环境，其它环境参考 [脱离 SpringBoot 单独使用](脱离SpringBoot单独使用)
+`pom.xml` 引入本项目，这里默认是 `SpringBoot` 环境，`Solon` 环境参考 [在 Solon 中使用](在Solon中使用)，其它环境参考 [脱离 SpringBoot 单独使用](脱离SpringBoot单独使用)
 
 ```xml
 <dependency>
     <groupId>org.dromara.x-file-storage</groupId>
     <artifactId>x-file-storage-spring</artifactId>
-    <version>2.1.0</version>
+    <version>2.2.0</version>
 </dependency>
 ```  
 
@@ -112,7 +112,7 @@
 <dependency>
     <groupId>cn.hutool</groupId>
     <artifactId>hutool-extra</artifactId>
-    <version>5.8.22</version>
+    <version>5.8.28</version>
 </dependency>
 
 <!-- Apache 的对象池 -->
@@ -136,7 +136,7 @@
 <dependency>
     <groupId>cn.hutool</groupId>
     <artifactId>hutool-extra</artifactId>
-    <version>5.8.22</version>
+    <version>5.8.28</version>
 </dependency>
 
 <!-- Apache 的对象池 -->
@@ -548,7 +548,7 @@ public class SpringFileStorageTestApplication {
 ## 开始使用
 
 ### 上传
-支持 File、MultipartFile、byte[]、InputStream、URL、URI、String、HttpServletRequest，大文件会自动分片上传。如果想支持更多方式，请阅读 [文件适配器](文件适配器) 章节
+支持 File、MultipartFile、UploadedFile、byte[]、InputStream、URL、URI、String、HttpServletRequest，大文件会自动分片上传。如果想支持更多方式，请阅读 [文件适配器](文件适配器) 章节
 
 
 ```java
@@ -573,6 +573,7 @@ public class FileDetailController {
     public String upload2(MultipartFile file) {
         FileInfo fileInfo = fileStorageService.of(file)
                 .setPath("upload/") //保存到相对路径下，为了方便管理，不需要可以不写
+                .setSaveFilename("image.jpg") //设置保存的文件名，不需要可以不写，会随机生成
                 .setObjectId("0")   //关联对象id，为了方便管理，不需要可以不写
                 .setObjectType("0") //关联对象类型，为了方便管理，不需要可以不写
                 .putAttr("role","admin") //保存一些属性，可以在切面、保存上传记录、自定义存储平台等地方获取使用，不需要可以不写
diff --git "a/docs/\346\226\207\344\273\266\351\200\202\351\205\215\345\231\250.md" "b/docs/\346\226\207\344\273\266\351\200\202\351\205\215\345\231\250.md"
index 0a27810b..a7498260 100644
--- "a/docs/\346\226\207\344\273\266\351\200\202\351\205\215\345\231\250.md"
+++ "b/docs/\346\226\207\344\273\266\351\200\202\351\205\215\345\231\250.md"
@@ -1,6 +1,6 @@
 # 文件适配器
 
-目前已支持 File、MultipartFile、byte[]、InputStream、URL、URI、String，支持自定义文件适配器
+目前已支持 File、MultipartFile、UploadedFile、byte[]、InputStream、URL、URI、String，支持自定义文件适配器
 
 这里用 byte[] 文件适配器举例
 
diff --git "a/docs/\346\233\264\346\226\260\350\256\260\345\275\225.md" "b/docs/\346\233\264\346\226\260\350\256\260\345\275\225.md"
index b383fa3d..a5e4573c 100644
--- "a/docs/\346\233\264\346\226\260\350\256\260\345\275\225.md"
+++ "b/docs/\346\233\264\346\226\260\350\256\260\345\275\225.md"
@@ -2,6 +2,22 @@
 
 -------
 
+## 📦2.2.0 :id=_220
+2024-07-02
+- 新增获取文件
+- 新增列举文件
+- 重构预签名 URL 支持客户端上传、下载、删除等操作
+- 新增 Solon 插件
+- 升级 Hutool 版本
+- 手动分片上传功能优化、以及增加对 GoogleCloud Storage 的支持
+- 优化缩略图异常处理
+- 优化代码结构
+- 修复分片场景下哈希值一致问题
+- 修复 Minio 分片上传偶发性报错
+- 修复本地存储添加静态资源访问未生效的问题
+
+-------
+
 ## 📦2.1.0 :id=_210
 2024-01-19
 - 新增 FastDFS 存储平台
diff --git "a/docs/\350\204\261\347\246\273SpringBoot\345\215\225\347\213\254\344\275\277\347\224\250.md" "b/docs/\350\204\261\347\246\273SpringBoot\345\215\225\347\213\254\344\275\277\347\224\250.md"
index 5d4458a6..807f98d8 100644
--- "a/docs/\350\204\261\347\246\273SpringBoot\345\215\225\347\213\254\344\275\277\347\224\250.md"
+++ "b/docs/\350\204\261\347\246\273SpringBoot\345\215\225\347\213\254\344\275\277\347\224\250.md"
@@ -8,7 +8,7 @@
 <dependency>
     <groupId>org.dromara.x-file-storage</groupId>
     <artifactId>x-file-storage-core</artifactId>
-    <version>2.1.0</version>
+    <version>2.2.0</version>
 </dependency>
 ```
 
diff --git "a/docs/\350\277\201\347\247\273\346\226\207\344\273\266.md" "b/docs/\350\277\201\347\247\273\346\226\207\344\273\266.md"
new file mode 100644
index 00000000..953e82f1
--- /dev/null
+++ "b/docs/\350\277\201\347\247\273\346\226\207\344\273\266.md"
@@ -0,0 +1,182 @@
+# 迁移文件
+
+
+## 从数据库读取迁移
+
+从 `2.1.0` 版本开始支持，适用于项目从一开始就把上传的文件记录全部保存到了数据库，这时候只要读取数据库记录，再使用复制或移动文件功能就可以了
+
+此方案实现起来简单，速度快，兼容性好，只要数据库中保存了 ACL（访问控制列表） 和 Metadata（元数据）等数据都可以一起迁移
+
+建议使用复制功能来迁移，全部复制完成后检查没问题了，再使用删除功能删除旧文件
+
+详情参考 [复制](基础功能?id=复制) 、 [移动（重命名）](基础功能?id=移动（重命名）) 和 [保存上传记录](基础功能?id=保存上传记录)
+
+<!-- fold:start -->
+
+```java
+@Slf4j
+@SpringBootTest
+class FileStorageServiceTransferTest {
+    @Autowired
+    private FileStorageService fileStorageService;
+    @Autowired
+    private FileDetailService fileDetailService;
+
+    /**
+     * 使用数据库迁移文件
+     */
+    @Test
+    public void transferByDb() {
+        // 目标存储平台
+        String toPlatform = "azure-blob-1";
+
+        // 从数据库中读取要迁移的文件信息
+        List<FileInfo> list = fileDetailService.list().stream()
+                .map(detail -> {
+                    try {
+                        return fileDetailService.toFileInfo(detail);
+                    } catch (JsonProcessingException e) {
+                        throw new RuntimeException(e);
+                    }
+                })
+                .collect(Collectors.toList());
+
+        for (FileInfo fileInfo : list) {
+            // 使用复制文件，会保留旧文件，推荐
+            fileStorageService
+                    .copy(fileInfo)
+                    .setPlatform(toPlatform)
+                    .setNotSupportMetadataThrowException(true) // 不支持元数据时抛出异常
+                    .setNotSupportAclThrowException(true) // 不支持 ACL 时抛出异常
+                    .setProgressListener((progressSize, allSize) -> log.info(
+                            "文件 {}{}{} 迁移进度：{} {}%",
+                            fileInfo.getBasePath(),
+                            fileInfo.getPath(),
+                            fileInfo.getFilename(),
+                            progressSize,
+                            progressSize * 100 / allSize))
+                    .copy();
+
+            // 使用移动文件，会删除旧文件，不推荐
+            // fileStorageService
+            //        .move(fileInfo)
+            //        .setPlatform(toPlatform)
+            //        .setNotSupportMetadataThrowException(true) // 不支持元数据时抛出异常
+            //        .setNotSupportAclThrowException(true) // 不支持 ACL 时抛出异常
+            //        .setProgressListener((progressSize, allSize) -> log.info(
+            //                "文件 {}{}{} 迁移进度：{} {}%",
+            //                fileInfo.getBasePath(),
+            //                fileInfo.getPath(),
+            //                fileInfo.getFilename(),
+            //                progressSize,
+            //                progressSize * 100 / allSize))
+            //        .move();
+        }
+    }
+}
+```
+
+<!-- fold:end -->
+
+## 从存储平台读取迁移
+
+从 `2.2.0` 版本开始支持，适用于迁移旧项目数据或未使用数据库等情况，需要使用列举文件功能递归获取到所有目录及文件
+
+此方案实现起来较为复杂， ACL（访问控制列表） 和 Metadata（元数据）等数据都需要手动处理
+
+建议使用复制功能来迁移，全部复制完成后检查没问题了，再使用删除功能删除旧文件
+
+详情参考 [列举文件](基础功能?id=列举文件) 、 [复制](基础功能?id=复制) 、 [移动（重命名）](基础功能?id=移动（重命名）) 和 [保存上传记录](基础功能?id=保存上传记录)
+
+<!-- fold:start -->
+
+```java
+@Slf4j
+@SpringBootTest
+class FileStorageServiceTransferTest {
+    @Autowired
+    private FileStorageService fileStorageService;
+
+    /**
+     * 从存储平台读取迁移
+     */
+    @Test
+    public void transferByPlatform() {
+        // 源存储平台
+        String fromPlatform = "azure-blob-1";
+        // 目标存储平台
+        String toPlatform = "huawei-obs-1";
+        // 要迁移的路径
+        String path = "";
+        // 开始迁移
+        transfer(fromPlatform, toPlatform, path);
+    }
+
+    /**
+     * 使用数据库迁移文件
+     */
+    public void transfer(String fromPlatform, String toPlatform, String path) {
+
+        // 例举出当前路径下所有目录及文件
+        ListFilesResult result = fileStorageService
+                .listFiles()
+                .setPlatform(fromPlatform)
+                .setPath(path)
+                .listFiles();
+
+        // 递归迁移所有子目录
+        for (RemoteDirInfo dir : result.getDirList()) {
+            transfer(fromPlatform, toPlatform, path + dir.getName() + "/");
+        }
+
+        // 迁移当前路径下所有文件
+        for (RemoteFileInfo remoteFileInfo : result.getFileList()) {
+            // 转换成 FileInfo，注意 createTime 、metadata 及 userMetadata 可能需要自行处理，详情查看方法源码注释
+            // 同时每个存储平台的 ACL 也不一样，也需要自行处理
+            FileInfo fileInfo = remoteFileInfo.toFileInfo();
+
+            // 这里仅保留需要的 metadata ，例如：
+            Map<String, String> fromMetadata = new KebabCaseInsensitiveMap<>(fileInfo.getMetadata());
+            Map<String, String> toMetadata = new HashMap<>();
+            if (fromMetadata.containsKey(Constant.Metadata.CONTENT_TYPE)) {
+                toMetadata.put(Constant.Metadata.CONTENT_TYPE, fromMetadata.get(Constant.Metadata.CONTENT_TYPE));
+            }
+            if (fromMetadata.containsKey(Constant.Metadata.CONTENT_LENGTH)) {
+                toMetadata.put(Constant.Metadata.CONTENT_LENGTH, fromMetadata.get(Constant.Metadata.CONTENT_LENGTH));
+            }
+            if (fromMetadata.containsKey(Constant.Metadata.CONTENT_DISPOSITION)) {
+                toMetadata.put(
+                        Constant.Metadata.CONTENT_DISPOSITION, fromMetadata.get(Constant.Metadata.CONTENT_DISPOSITION));
+            }
+            fileInfo.setMetadata(toMetadata);
+
+            // 使用复制文件，会保留旧文件，推荐
+            fileStorageService
+                    .move(fileInfo)
+                    .setPlatform(toPlatform)
+                    .setNotSupportMetadataThrowException(true) // 不支持元数据时抛出异常
+                    .setNotSupportAclThrowException(true) // 不支持 ACL 时抛出异常
+                    .setProgressListener((progressSize, allSize) -> log.info(
+                            "文件 {}/{} 迁移进度：{} {}%",
+                            fileInfo.getPath(), fileInfo.getFilename(), progressSize, progressSize * 100 / allSize))
+                    .move();
+            // 使用移动文件，会删除旧文件，不推荐
+            // fileStorageService
+            //        .copy(fileInfo)
+            //        .setPlatform(toPlatform)
+            //        .setNotSupportMetadataThrowException(true) // 不支持元数据时抛出异常
+            //        .setNotSupportAclThrowException(true) // 不支持 ACL 时抛出异常
+            //        .setProgressListener((progressSize, allSize) -> log.info(
+            //                "文件 {}/{} 迁移进度：{} {}%",
+            //                fileInfo.getPath(), fileInfo.getFilename(), progressSize, progressSize * 100 / allSize))
+            //        .copy();
+        }
+    }
+}
+```
+
+<!-- fold:end -->
+
+> [!WARNING|label:重要提示：]
+> 1、如果之前有用过上传文件并生成缩略图功能，此种迁移方式会当成两个独立的文件来操作，且操作完成后数据库中会有两条文件记录，有需要可自行查找出对应关系进行合并<br />
+> 2、处理 ACL（访问控制列表） 或 Metadata（元数据）等要小心，每个存储平台返回的结果都不太一样互相之间都可能不兼容
diff --git "a/docs/\351\242\204\347\255\276\345\220\215URL.md" "b/docs/\351\242\204\347\255\276\345\220\215URL.md"
index 7b67a546..17d533ea 100644
--- "a/docs/\351\242\204\347\255\276\345\220\215URL.md"
+++ "b/docs/\351\242\204\347\255\276\345\220\215URL.md"
@@ -2,21 +2,209 @@
 
 有时文件是存储在私有桶里的，或者文件的 ACL 是私有的，无法直接访问，这时候我们就可以通过生成一个预签名 URL 来达到临时访问的目的
 
+又或者想实现客户端上传等，也可以通过此功能来实现
 
+目前仅 华为云 OBS、阿里云 OSS、七牛云 Kodo、腾讯云 COS、百度云 BOS、MinIO、Amazon S3、GoogleCloud Storage、Azure Blob Storage 平台支持
 
-## 生成
+## 基本用法
 
-目前仅 华为云 OBS、阿里云 OSS、七牛云 Kodo、腾讯云 COS、百度云 BOS、MinIO、Amazon S3、GoogleCloud Storage、Azure Blob Storage 平台支持
+基本的下载用法，`2.2.0` 之前的版本仅支持这种用法，仅能生成用于访问或下载的 URL
 
 ```java
 //判断对应的存储平台是否支持预签名 URL
 FileStorage storage = fileStorageService.getFileStorage();
 boolean supportPresignedUrl = fileStorageService.isSupportPresignedUrl(storage);
 
-//生成 URL ，有效期为1小时
-String presignedUrl = fileStorageService.generatePresignedUrl(fileInfo,DateUtil.offsetHour(new Date(),1));
-System.out.println("文件授权访问地址：" + presignedUrl);
+//快速生成用于访问或下载的 URL ，有效期为1小时
+String presignedUrl = fileStorageService.generatePresignedUrl(fileInfo, DateUtil.offsetHour(new Date(), 1));
+System.out.
+
+println("文件授权访问地址："+presignedUrl);
+
+String thPresignedUrl = fileStorageService.generateThPresignedUrl(fileInfo, DateUtil.offsetHour(new Date(), 1));
+System.out.
+
+println("缩略图文件授权访问地址："+thPresignedUrl);
+```
+
+## 高级用法
+
+`2.2.0` 开始支持更多高级用法，主要通过 `Method` 控制，例如上传是 `PUT` ，下载是 `GET` ，删除是 `DELETE`，详情可以参考以下链接
+
+| 存储平台                | 说明                                                                                                                 | 参考链接                                                                                                                                  |
+|---------------------|--------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|
+| 华为云 OBS             | 支持 GET、POST、PUT、DELETE、HEAD                                                                                        | [查看](https://support.huaweicloud.com/sdk-java-devg-obs/obs_21_0901.html)                                                              |
+| 阿里云 OSS             | 支持 GET、PUT                                                                                                         | [查看](https://help.aliyun.com/zh/oss/developer-reference/authorize-access-1?spm=a2c4g.11186623.0.0.21ec3b2bHHPzJn#section-8ii-3zg-2ib) |
+| 七牛云 Kodo            | 官方 SDK 仅支持 GET ，可以通过 Amazon S3 的 SDK 来使用七牛云 Kodo ：[兼容性说明](https://developer.qiniu.com/kodo/4086/aws-s3-compatible) | [查看](https://help.aliyun.com/zh/oss/developer-reference/authorize-access-1?spm=a2c4g.11186623.0.0.21ec3b2bHHPzJn#section-8ii-3zg-2ib) |
+| 腾讯云 COS             | 支持 GET、POST、PUT、DELETE、HEAD                                                                                        | [查看](https://cloud.tencent.com/document/product/436/35217)                                                                            |
+| 百度云 BOS             | 支持 GET、PUT、DELETE、HEAD                                                                                             | [查看](https://cloud.baidu.com/doc/BOS/s/Wl60p2b61)                                                                                     |
+| MinIO               | 支持 GET、POST、PUT、DELETE、HEAD                                                                                        | [查看](https://min.io/docs/minio/linux/developers/java/API.html#getPresignedObjectUrl)                                                  |
+| Amazon S3           | 支持 GET、POST、PUT、DELETE、HEAD                                                                                        | [查看](https://docs.aws.amazon.com/zh_cn/AmazonS3/latest/userguide/using-presigned-url.html)                                            |
+| GoogleCloud Storage | 支持 GET、POST、PUT、DELETE、HEAD                                                                                        | [查看](https://cloud.google.com/storage/docs/access-control/signed-urls?hl=zh-cn)                                                       |
+| Azure Blob Storage  | 默认支持 GET、PUT、DELETE  ，可在配置文件中通过 methodToPermissionMap 参数自行扩展                                                       | [查看](https://learn.microsoft.com/zh-cn/azure/storage/blobs/sas-service-create-java)                                                   |
+
+> [!TIP|label:说明：]
+> 在使用过程中，由于每个存储平台支持情况各不相同，可能会出现某些功能不生效的情况，可自行查询相关文档
+
+### 下载
+
+```java
+// 获取一个 FileInfo
+FileInfo fileInfo = fileStorageService.getFileInfoByUrl("https://aa.bb.com/aa/bb/cc.jpg");
+
+// 生成下载或访问用的 URL
+GeneratePresignedUrlResult downloadResult = fileStorageService
+        .generatePresignedUrl()
+        .setPlatform(fileInfo.getPlatform()) // 存储平台，不传使用默认的
+        .setPath(fileInfo.getPath()) // 文件路径
+        .setFilename(fileInfo.getFilename()) // 文件名，也可以换成缩略图的文件名
+        .setMethod(Constant.GeneratePresignedUrl.Method.GET) // 签名方法
+        .setExpiration(DateUtil.offsetMinute(new Date(), 10)) // 过期时间 10 分钟
+        .putResponseHeaders(
+                // 设置一个响应头，将下载时的文件名改成 NewDownloadFileName.jpg，不需要可省略
+                // 这里也可以设置其它的想要的响应头，每个存储平台支持情况都不太相同，可以自行测试或查询相关文档
+                Constant.Metadata.CONTENT_DISPOSITION, "attachment;filename=NewDownloadFileName.jpg")
+        .generatePresignedUrl();
+
+info("生成访问预签名 URL 结果：{}",downloadResult);
+
+//根据获得的 URL 下载文件
+byte[] downloadBytes = HttpUtil.downloadBytes(downloadResult.getUrl());
+```
+
+### 上传
+
+生成上传 URL 给客户端，从而实现客户端直传文件，不经过后台，目前这种方式不支持附带缩略图，将在后续版本提供追加缩略图功能，也不支持设置 `ACL`，可以上传后通过后台设置 `ACL`
+
+**第一步：**
+
+服务端根据需求生成上传 URL 及 Headers
+
+```java
+GeneratePresignedUrlResult uploadResult = fileStorageService
+                .generatePresignedUrl()
+                .setPlatform("google-cloud-1") // 存储平台，不传使用默认的
+                .setPath("test/") // 设置路径
+                .setFilename("image.jpg") // 设置保存的文件名
+                .setMethod(Constant.GeneratePresignedUrl.Method.PUT)    // 签名方法
+                .setExpiration(DateUtil.offsetMinute(new Date(), 10))   // 设置过期时间 10 分钟
+                .putHeaders(Constant.Metadata.CONTENT_TYPE, "image/jpeg") // 设置要上传文件 MIME 类型
+                .putHeaders(Constant.Metadata.CONTENT_DISPOSITION, "attachment;filename=DownloadFileName.jpg") //设置其它元数据，不需要可省略
+                .putUserMetadata("role", "666") //设置自定义用户元数据，不需要可省略
+                .putQueryParams("admin", "123456") //设置自定义查询参数，不需要可省略
+                .generatePresignedUrl();
+Assert.notNull(uploadResult, "生成上传预签名 URL 失败！");
+log.info("生成上传预签名 URL 结果：{}", uploadResult);
+```
+
+**第二步：**
+
+客户端根据得到的 URL 和 Headers 进行上传。注意这里使用 REST 风格上传，body 直接就是文件内容，不是传统的 FormData 形式
+
+Java 写法
+
+```java
+byte[] bytes = FileUtil.readBytes("C:\\001.jpg");
+String body = HttpRequest.of(uploadResult.getUrl())
+        .method(Method.PUT)
+        .addHeaders(uploadResult.getHeaders())  //需要添加 Headers ，这一步必不可少
+        .body(bytes) //文件内容的 byte 数据
+        .execute()
+        .body();
+
+//根据返回值判断是否上传成功
+Assert.isTrue(StrUtil.isBlank(body), "生成上传预签名 URL 失败：{}", body);
+```
+
+JS 写法
+
+```js
+let input = document.createElement('input')
+input.type = 'file'
+input.accept = '.jpg'
+input.oninput = async _ => {
+    console.log(input.files)
+    let file = input.files[0]
+
+    //使用 fetch 上传
+    let response = await fetch(uploadResult.url, {
+        method: 'PUT',
+        headers: uploadResult.headers,
+        body: file,
+        onProgress: (progress) => {
+            console.log(`上传进度: ${Math.round((progress.loaded / progress.total) * 100)}%`);
+        }
+    });
+
+    //验证是否上传成功
+    if (response.ok) {
+        console.log('File uploaded successfully!');
+    } else {
+        console.error('Error uploading file:', response.status);
+    }
+}
+input.click()
+```
+
+> [!WARNING|label:重要提示：]
+> 使用 JS 在浏览器中进行上传文件等操作时，可能会遇到跨域问题，请到对应存储平台的控制台操作 CORS 相关配置<br />
+> GoogleCloud Storage 不支持在控制台中设置，可以使用以下方式通过代码设置，其它存储平台自行查询相关文档
+
+```java
+// 每个存储通只需要设置一次即可，参考文档：https://cloud.google.com/storage/docs/cross-origin?hl=zh-cn
+GoogleCloudStorageFileStorage storage = fileStorageService.getFileStorage("google-cloud-1"); //获取对应的存贮平台
+Storage client = storage.getClient();
+Bucket bucket = client.get(storage.getBucketName());
+String origin = "*"; // 域名，例如 www.baidu.com  或者 *.baidu.com 允许全部直接设置成 *
+HttpMethod method = HttpMethod.PUT; // 请求方法，上传文件是 PUT 下载文件是 GET
+String responseHeader = "*"; // 响应头
+Integer maxAgeSeconds = 3600; // 时间
+Cors cors = Cors.newBuilder()
+        .setOrigins(ImmutableList.of(Cors.Origin.of(origin)))
+        .setMethods(ImmutableList.of(method))
+        .setResponseHeaders(ImmutableList.of(responseHeader))
+        .setMaxAgeSeconds(maxAgeSeconds)
+        .build();
+bucket.toBuilder().setCors(ImmutableList.of(cors)).build().update();
+```
+
+**第三步：**
+
+参考 [获取文件](基础功能?id=获取文件)  查询已上传的文件，这部分可省略
+
+```java
+//自行传入 path 及 filename 获取文件信息
+RemoteFileInfo info3 = fileStorageService.getFile().setPath("test/").setFilename("image.jpg").getFile();
+Assert.notNull(info3, "文件不存在");
+log.info("获取文件结果：{}", info3);
+//文件元数据
+MapProxy metadata = info3.getKebabCaseInsensitiveMetadata();
+//文件用户元数据
+MapProxy userMetadata = info3.getKebabCaseInsensitiveUserMetadata();
+
+//转换成 FileInfo 可方便进行其它操作或保存到数据库中
+FileInfo fileInfo = info3.toFileInfo();
+```
+
+### 删除
+
+```java
+GeneratePresignedUrlResult deleteResult = fileStorageService
+        .generatePresignedUrl()
+        .setPath("test/")
+        .setFilename("image.jpg")
+        .setMethod(Constant.GeneratePresignedUrl.Method.DELETE)
+        .setExpiration(DateUtil.offsetMinute(new Date(), 10))
+        // Hutool HTTP 工具默认发送的 Content-Type 是 application/x-www-form-urlencoded
+        // 会导致签名错误，这里强制传入一个 Content-Type 用于覆盖默认的可以解决这个问题
+        // 其它请求工具类可以忽略这个参数
+        .putHeaders(Constant.Metadata.CONTENT_TYPE, "image/jpeg")
+        .generatePresignedUrl();
 
-String thPresignedUrl = fileStorageService.generateThPresignedUrl(fileInfo,DateUtil.offsetHour(new Date(),1));
-System.out.println("缩略图文件授权访问地址：" + thPresignedUrl);
+// 使用 Hutool HTTP 工具访问 URL 实现删除文件，其它语言也类似，浏览器中也会有跨域问题，可以参考签名的上传章节
+String deleteHttpResponse = HttpRequest.of(deleteResult.getUrl())
+        .method(Method.DELETE)
+        .addHeaders(deleteResult.getHeaders())
+        .execute()
+        .body();
 ```
diff --git a/pom.xml b/pom.xml
index daf1d942..ea658598 100644
--- a/pom.xml
+++ b/pom.xml
@@ -52,11 +52,20 @@
                 <role>Contrib</role>
             </roles>
         </developer>
+        <developer>
+            <id>yang37</id>
+            <name>yang37</name>
+            <email>yang37z@qq.com</email>
+            <roles>
+                <role>Contrib</role>
+            </roles>
+        </developer>
     </developers>
 
     <modules>
         <module>x-file-storage-spring</module>
         <module>x-file-storage-core</module>
+        <module>x-file-storage-solon</module>
     </modules>
 
     <scm>
@@ -66,7 +75,7 @@
     </scm>
 
     <properties>
-        <revision>2.1.0</revision>
+        <revision>2.2.0</revision>
         <!--region Maven Base-->
         <maven.version>3.8.1</maven.version>
         <java.version>8</java.version>
@@ -78,6 +87,8 @@
 
         <!-- Spring 组件 -->
         <spring-boot.version>2.7.2</spring-boot.version>
+        <!-- Solon 组件 -->
+        <solon.version>2.8.4</solon.version>
 
         <!--region 3rd SDK-->
         <aliyun-sdk-oss.version>3.16.1</aliyun-sdk-oss.version>
@@ -88,7 +99,7 @@
         <cos_api.version>5.6.137</cos_api.version>
         <esdk-obs-java.version>3.22.12</esdk-obs-java.version>
         <google-cloud-storage.version>2.20.1</google-cloud-storage.version>
-        <hutool.version>5.8.22</hutool.version>
+        <hutool.version>5.8.28</hutool.version>
         <javax.servlet-api.version>4.0.1</javax.servlet-api.version>
         <jakarta.servlet-api.version>5.0.0</jakarta.servlet-api.version>
         <jsch.version>0.1.55</jsch.version>
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileInfo.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileInfo.java
index e1573480..98a20074 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileInfo.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileInfo.java
@@ -5,12 +5,14 @@
 import java.util.Date;
 import java.util.Map;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 import lombok.experimental.Accessors;
 import org.dromara.x.file.storage.core.constant.Constant;
 import org.dromara.x.file.storage.core.hash.HashInfo;
 
 @Data
 @Accessors(chain = true)
+@NoArgsConstructor
 public class FileInfo implements Serializable {
 
     /**
@@ -167,4 +169,10 @@ public class FileInfo implements Serializable {
     private Date createTime;
 
     private static final long serialVersionUID = 1L;
+
+    public FileInfo(String basePath, String path, String filename) {
+        this.basePath = basePath;
+        this.path = path;
+        this.filename = filename;
+    }
 }
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageProperties.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageProperties.java
index d93a6eb1..c25a4b29 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageProperties.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageProperties.java
@@ -1,5 +1,6 @@
 package org.dromara.x.file.storage.core;
 
+import cn.hutool.core.map.MapBuilder;
 import cn.hutool.core.util.StrUtil;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
@@ -781,7 +782,7 @@ public static class GoogleCloudStorageConfig extends BaseConfig {
 
     /**
      * FastDFS
-     * 兼容性说明：https://x-file-storage.xuyanwu.cn/2.1.0/#/%E5%AD%98%E5%82%A8%E5%B9%B3%E5%8F%B0?id=OCI_FastDFS
+     * 兼容性说明：https://x-file-storage.xuyanwu.cn/2.2.0/#/%E5%AD%98%E5%82%A8%E5%B9%B3%E5%8F%B0?id=OCI_FastDFS
      */
     @Data
     @Accessors(chain = true)
@@ -789,7 +790,7 @@ public static class GoogleCloudStorageConfig extends BaseConfig {
     public static class FastDfsConfig extends BaseConfig {
         /**
          * 运行模式，由于 FastDFS 比较特殊，不支持自定义文件名及路径，所以使用运行模式来解决这个问题。
-         * 详情请查看：https://x-file-storage.xuyanwu.cn/2.1.0/#/%E5%AD%98%E5%82%A8%E5%B9%B3%E5%8F%B0?id=OCI_FastDFS
+         * 详情请查看：https://x-file-storage.xuyanwu.cn/2.2.0/#/%E5%AD%98%E5%82%A8%E5%B9%B3%E5%8F%B0?id=OCI_FastDFS
          */
         private RunMod runMod = RunMod.COVER;
 
@@ -815,10 +816,10 @@ public static class FastDfsConfig extends BaseConfig {
 
         /**
          * 基础路径，强烈建议留空
-         * 仅在上传成功时原样传到 FileInfo 中，可以用来保存到数据库中使用，
+         * 仅在上传成功时和获取文件时原样传到 FileInfo 及 RemoteFileInfo 中，可以用来保存到数据库中使用，
          * 实际上作用也不大，还会破坏 url 约定（url：实际上就是 domain + basePath + path + filename），
-         * 约定详情见文档 https://x-file-storage.xuyanwu.cn/2.1.0/#/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98?id=%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6%E5%8F%8A-fileinfo-%E4%B8%AD%E5%90%84%E7%A7%8D%E8%B7%AF%E5%BE%84%EF%BC%88path%EF%BC%89%E7%9A%84%E5%8C%BA%E5%88%AB%EF%BC%9F
-         * FastDFS 兼容性说明：https://x-file-storage.xuyanwu.cn/2.1.0/#/%E5%AD%98%E5%82%A8%E5%B9%B3%E5%8F%B0?id=OCI_FastDFS
+         * 约定详情见文档 https://x-file-storage.xuyanwu.cn/2.2.0/#/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98?id=%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6%E5%8F%8A-fileinfo-%E4%B8%AD%E5%90%84%E7%A7%8D%E8%B7%AF%E5%BE%84%EF%BC%88path%EF%BC%89%E7%9A%84%E5%8C%BA%E5%88%AB%EF%BC%9F
+         * FastDFS 兼容性说明：https://x-file-storage.xuyanwu.cn/2.2.0/#/%E5%AD%98%E5%82%A8%E5%B9%B3%E5%8F%B0?id=OCI_FastDFS
          */
         private String basePath = "";
 
@@ -847,12 +848,12 @@ public String getGroupName() {
         public enum RunMod {
             /**
              * 覆盖模式，强制用 FastDFS 返回的路径及文件名覆盖 FileInfo 中的 path 及 filename。
-             * 详情请查看：https://x-file-storage.xuyanwu.cn/2.1.0/#/%E5%AD%98%E5%82%A8%E5%B9%B3%E5%8F%B0?id=OCI_FastDFS
+             * 详情请查看：https://x-file-storage.xuyanwu.cn/2.2.0/#/%E5%AD%98%E5%82%A8%E5%B9%B3%E5%8F%B0?id=OCI_FastDFS
              */
             COVER,
             /**
              * URL模式，不覆盖 FileInfo 中的 path 及 filename。通过 url 解析 FastDFS 支持的路径及文件名
-             * 详情请查看：https://x-file-storage.xuyanwu.cn/2.1.0/#/%E5%AD%98%E5%82%A8%E5%B9%B3%E5%8F%B0?id=OCI_FastDFS
+             * 详情请查看：https://x-file-storage.xuyanwu.cn/2.2.0/#/%E5%AD%98%E5%82%A8%E5%B9%B3%E5%8F%B0?id=OCI_FastDFS
              */
             URL;
         }
@@ -998,6 +999,19 @@ public static class AzureBlobStorageConfig extends BaseConfig {
          */
         private int maxConcurrency = 8;
 
+        /**
+         * 预签名 URL 时，传入的 HTTP method 与 Azure Blob Storage 中的 SAS 权限映射表，
+         * 目前默认支持 GET （获取），PUT（上传），DELETE（删除），
+         * 其它可以自行扩展，例如你想自定义一个 ALL 的 method，赋予所有权限，可以写为 .put("ALL", "racwdxytlmei")
+         * {@link com.azure.storage.blob.sas.BlobSasPermission}
+         */
+        private Map<String, String> methodToPermissionMap = MapBuilder.create(new HashMap<String, String>())
+                .put(Constant.GeneratePresignedUrl.Method.GET, "r") // 获取
+                .put(Constant.GeneratePresignedUrl.Method.PUT, "w") // 上传
+                .put(Constant.GeneratePresignedUrl.Method.DELETE, "d") // 删除
+                // .put("ALL", "racwdxytlmei")    //自定义一个名为 ALL 的 method，赋予所有权限
+                .build();
+
         /**
          * 其它自定义配置
          */
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageService.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageService.java
index 0e9c06fb..d8c00348 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageService.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageService.java
@@ -11,18 +11,25 @@
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 import org.dromara.x.file.storage.core.aspect.*;
+import org.dromara.x.file.storage.core.constant.Constant;
 import org.dromara.x.file.storage.core.copy.CopyPretreatment;
 import org.dromara.x.file.storage.core.exception.FileStorageRuntimeException;
 import org.dromara.x.file.storage.core.file.FileWrapper;
 import org.dromara.x.file.storage.core.file.FileWrapperAdapter;
 import org.dromara.x.file.storage.core.file.HttpServletRequestFileWrapper;
 import org.dromara.x.file.storage.core.file.MultipartFormDataReader;
+import org.dromara.x.file.storage.core.get.GetFilePretreatment;
+import org.dromara.x.file.storage.core.get.ListFilesPretreatment;
+import org.dromara.x.file.storage.core.get.ListFilesSupportInfo;
+import org.dromara.x.file.storage.core.get.RemoteFileInfo;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
 import org.dromara.x.file.storage.core.platform.FileStorage;
-import org.dromara.x.file.storage.core.platform.MultipartUploadSupportInfo;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.recorder.FileRecorder;
 import org.dromara.x.file.storage.core.tika.ContentTypeDetect;
 import org.dromara.x.file.storage.core.upload.*;
+import org.dromara.x.file.storage.core.upload.MultipartUploadSupportInfo;
 import org.dromara.x.file.storage.core.upload.UploadPretreatment;
 import org.dromara.x.file.storage.core.util.Tools;
 
@@ -199,6 +206,13 @@ public Downloader downloadTh(String url) {
         return self.downloadTh(getFileInfoByUrl(url));
     }
 
+    /**
+     * 是否支持对文件生成可以签名访问的 URL
+     */
+    public boolean isSupportPresignedUrl() {
+        return self.isSupportPresignedUrl(properties.getDefaultPlatform());
+    }
+
     /**
      * 是否支持对文件生成可以签名访问的 URL
      */
@@ -215,6 +229,16 @@ public boolean isSupportPresignedUrl(FileStorage fileStorage) {
         return new IsSupportPresignedUrlAspectChain(aspectList, FileStorage::isSupportPresignedUrl).next(fileStorage);
     }
 
+    /**
+     * 生成预签名 URL
+     * @return 生成预签名 URL 预处理器
+     */
+    public GeneratePresignedUrlPretreatment generatePresignedUrl() {
+        return new GeneratePresignedUrlPretreatment()
+                .setFileStorageService(self)
+                .setPlatform(properties.getDefaultPlatform());
+    }
+
     /**
      * 对文件生成可以签名访问的 URL，无法生成则返回 null
      *
@@ -222,11 +246,13 @@ public boolean isSupportPresignedUrl(FileStorage fileStorage) {
      */
     public String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
         if (fileInfo == null) return null;
-        return new GeneratePresignedUrlAspectChain(
-                        aspectList,
-                        (_fileInfo, _expiration, _fileStorage) ->
-                                _fileStorage.generatePresignedUrl(_fileInfo, _expiration))
-                .next(fileInfo, expiration, self.getFileStorageVerify(fileInfo));
+        GeneratePresignedUrlResult result = generatePresignedUrl()
+                .setExpiration(expiration)
+                .setPath(fileInfo.getPath())
+                .setFilename(fileInfo.getFilename())
+                .setMethod(Constant.GeneratePresignedUrl.Method.GET)
+                .generatePresignedUrl();
+        return result == null ? null : result.getUrl();
     }
 
     /**
@@ -236,11 +262,20 @@ public String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
      */
     public String generateThPresignedUrl(FileInfo fileInfo, Date expiration) {
         if (fileInfo == null) return null;
-        return new GenerateThPresignedUrlAspectChain(
-                        aspectList,
-                        (_fileInfo, _expiration, _fileStorage) ->
-                                _fileStorage.generateThPresignedUrl(_fileInfo, _expiration))
-                .next(fileInfo, expiration, self.getFileStorageVerify(fileInfo));
+        GeneratePresignedUrlResult result = generatePresignedUrl()
+                .setExpiration(expiration)
+                .setPath(fileInfo.getPath())
+                .setFilename(fileInfo.getThFilename())
+                .setMethod(Constant.GeneratePresignedUrl.Method.GET)
+                .generatePresignedUrl();
+        return result == null ? null : result.getUrl();
+    }
+
+    /**
+     * 是否支持对文件的访问控制列表
+     */
+    public boolean isSupportAcl() {
+        return self.isSupportAcl(properties.getDefaultPlatform());
     }
 
     /**
@@ -281,6 +316,13 @@ public boolean setThFileAcl(FileInfo fileInfo, Object acl) {
                 .next(fileInfo, acl, self.getFileStorageVerify(fileInfo));
     }
 
+    /**
+     * 是否支持 Metadata
+     */
+    public boolean isSupportMetadata() {
+        return self.isSupportMetadata(properties.getDefaultPlatform());
+    }
+
     /**
      * 是否支持 Metadata
      */
@@ -415,7 +457,7 @@ public UploadPartPretreatment uploadPart(FileInfo fileInfo, int partNumber, Obje
      *                 一定要保证这里的 fileInfo 也有相同的信息，否则有些存储平台会不生效，
      *                 这是因为每个存储平台的逻辑不一样，有些是初始化时传入的，有些是完成时传入的，
      *                 建议将 FileInfo 保存到数据库中，这样就可以使用 fileStorageService.getFileInfoByUrl("https://abc.def.com/xxx.png")
-     *                 来获取 FileInfo 方便操作，详情请阅读 https://x-file-storage.xuyanwu.cn/2.1.0/#/%E5%9F%BA%E7%A1%80%E5%8A%9F%E8%83%BD?id=%E4%BF%9D%E5%AD%98%E4%B8%8A%E4%BC%A0%E8%AE%B0%E5%BD%95
+     *                 来获取 FileInfo 方便操作，详情请阅读 https://x-file-storage.xuyanwu.cn/2.2.0/#/%E5%9F%BA%E7%A1%80%E5%8A%9F%E8%83%BD?id=%E4%BF%9D%E5%AD%98%E4%B8%8A%E4%BC%A0%E8%AE%B0%E5%BD%95
      */
     public CompleteMultipartUploadPretreatment completeMultipartUpload(FileInfo fileInfo) {
         CompleteMultipartUploadPretreatment pre = new CompleteMultipartUploadPretreatment();
@@ -444,6 +486,76 @@ public ListPartsPretreatment listParts(FileInfo fileInfo) {
         return pre;
     }
 
+    /**
+     * 默认使用的存储平台是否支持列举文件
+     */
+    public ListFilesSupportInfo isSupportListFiles() {
+        return self.isSupportListFiles(properties.getDefaultPlatform());
+    }
+
+    /**
+     * 是否支持列举文件
+     */
+    public ListFilesSupportInfo isSupportListFiles(String platform) {
+        FileStorage storage = self.getFileStorageVerify(platform);
+        return self.isSupportListFiles(storage);
+    }
+
+    /**
+     * 是否支持列举文件
+     */
+    public ListFilesSupportInfo isSupportListFiles(FileStorage fileStorage) {
+        if (fileStorage == null) return ListFilesSupportInfo.notSupport();
+        return new IsSupportListFilesAspectChain(aspectList, FileStorage::isSupportListFiles).next(fileStorage);
+    }
+
+    /**
+     * 列举文件
+     */
+    public ListFilesPretreatment listFiles() {
+        ListFilesPretreatment pre = new ListFilesPretreatment();
+        pre.setPlatform(properties.getDefaultPlatform());
+        pre.setFileStorageService(self);
+        return pre;
+    }
+
+    /**
+     * 获取文件
+     */
+    public GetFilePretreatment getFile() {
+        return new GetFilePretreatment()
+                .setPlatform(properties.getDefaultPlatform())
+                .setFileStorageService(self);
+    }
+
+    /**
+     * 获取文件
+     * @param fileInfo 文件信息
+     * @return 远程文件信息
+     */
+    public RemoteFileInfo getFile(FileInfo fileInfo) {
+        return getFile()
+                .setPlatform(fileInfo.getPlatform())
+                .setPath(fileInfo.getPath() != null, fileInfo.getPath())
+                .setFilename(fileInfo.getFilename() != null, fileInfo.getFilename())
+                .setUrl(fileInfo.getUrl() != null, fileInfo.getUrl())
+                .getFile();
+    }
+
+    /**
+     * 获取缩略图文件
+     * @param fileInfo 文件信息
+     * @return 远程文件信息
+     */
+    public RemoteFileInfo getThFile(FileInfo fileInfo) {
+        return getFile()
+                .setPlatform(fileInfo.getPlatform())
+                .setPath(fileInfo.getPath() != null, fileInfo.getPath())
+                .setFilename(fileInfo.getThFilename() != null, fileInfo.getThFilename())
+                .setUrl(fileInfo.getThUrl() != null, fileInfo.getThUrl())
+                .getFile();
+    }
+
     /**
      * 创建上传预处理器
      *
@@ -521,6 +633,13 @@ public FileWrapper wrapper(Object source, String name, String contentType, Long
         throw new FileStorageRuntimeException("不支持此文件");
     }
 
+    /**
+     * 是否支持同存储平台复制文件
+     */
+    public boolean isSupportSameCopy() {
+        return self.isSupportSameCopy(properties.getDefaultPlatform());
+    }
+
     /**
      * 是否支持同存储平台复制文件
      */
@@ -553,6 +672,13 @@ public CopyPretreatment copy(String url) {
         return self.copy(self.getFileInfoByUrl(url));
     }
 
+    /**
+     * 是否支持同存储平台移动文件
+     */
+    public boolean isSupportSameMove() {
+        return self.isSupportSameMove(properties.getDefaultPlatform());
+    }
+
     /**
      * 是否支持同存储平台移动文件
      */
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageServiceBuilder.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageServiceBuilder.java
index 702fe744..6a0fdab4 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageServiceBuilder.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/FileStorageServiceBuilder.java
@@ -612,7 +612,7 @@ public static void buildFileStorageDetect(List<?> list, String platformName, Str
             if (doesNotExistClass(className)) {
                 throw new FileStorageRuntimeException(
                         "检测到【" + platformName + "】配置，但是没有找到对应的依赖类：【" + className
-                                + "】，所以无法加载此存储平台！配置参考地址：https://x-file-storage.xuyanwu.cn/2.1.0/#/%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8");
+                                + "】，所以无法加载此存储平台！配置参考地址：https://x-file-storage.xuyanwu.cn/2.2.0/#/%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8");
             }
         }
     }
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/UploadPretreatment.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/UploadPretreatment.java
index 2ecf01f2..3a8fb22a 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/UploadPretreatment.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/UploadPretreatment.java
@@ -54,6 +54,10 @@ public class UploadPretreatment
      * 一旦缩略图生成后，扩展名之外的部分可以随意改变 ，扩展名部分不能改变，除非你在 {@link UploadPretreatment#thumbnail} 方法中修改了输出格式。
      */
     private String thumbnailSuffix;
+    /**
+     * 忽略生成缩略图时的错误，需要在生成缩略图之前设置
+     */
+    private boolean ignoreThumbnailException = false;
     /**
      * 文件所属对象id
      */
@@ -179,6 +183,14 @@ public UploadPretreatment setThumbnailSuffix(boolean flag, String thumbnailSuffi
         return this;
     }
 
+    /**
+     * 忽略生成缩略图时的错误，需要在生成缩略图之前设置
+     */
+    public UploadPretreatment setIgnoreThumbnailException(boolean flag, boolean ignoreThumbnailException) {
+        if (flag) setIgnoreThumbnailException(ignoreThumbnailException);
+        return this;
+    }
+
     /**
      * 设置文件所属对象id
      *
@@ -611,10 +623,10 @@ public UploadPretreatment thumbnailOf(boolean flag, Object file) {
     public UploadPretreatment thumbnailOf(Object file) {
         try {
             thumbnailBytes = IoUtil.readBytes(fileStorageService.wrapper(file).getInputStream());
-            return this;
         } catch (IOException e) {
-            throw new FileStorageRuntimeException("生成缩略图失败！", e);
+            if (!ignoreThumbnailException) throw new FileStorageRuntimeException("生成缩略图失败！", e);
         }
+        return this;
     }
 
     /**
@@ -637,8 +649,9 @@ public UploadPretreatment thumbnailOf(Object file, Consumer<Thumbnails.Builder<?
         try {
             return thumbnail(consumer, fileStorageService.wrapper(file).getInputStream());
         } catch (IOException e) {
-            throw new FileStorageRuntimeException("生成缩略图失败！", e);
+            if (!ignoreThumbnailException) throw new FileStorageRuntimeException("生成缩略图失败！", e);
         }
+        return this;
     }
 
     /**
@@ -662,8 +675,9 @@ public UploadPretreatment thumbnail(Consumer<Thumbnails.Builder<? extends InputS
                 return thumbnail(consumer, new ByteArrayInputStream(thumbnailBytes));
             }
         } catch (IOException e) {
-            throw new FileStorageRuntimeException("生成缩略图失败！", e);
+            if (!ignoreThumbnailException) throw new FileStorageRuntimeException("生成缩略图失败！", e);
         }
+        return this;
     }
 
     /**
@@ -679,10 +693,10 @@ private UploadPretreatment thumbnail(Consumer<Thumbnails.Builder<? extends Input
             ByteArrayOutputStream out = new ByteArrayOutputStream();
             builder.toOutputStream(out);
             thumbnailBytes = out.toByteArray();
-            return this;
         } catch (IOException e) {
-            throw new FileStorageRuntimeException("生成缩略图失败！", e);
+            if (!ignoreThumbnailException) throw new FileStorageRuntimeException("生成缩略图失败！", e);
         }
+        return this;
     }
 
     /**
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/FileStorageAspect.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/FileStorageAspect.java
index 7dd55693..62211528 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/FileStorageAspect.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/FileStorageAspect.java
@@ -6,12 +6,15 @@
 import org.dromara.x.file.storage.core.FileInfo;
 import org.dromara.x.file.storage.core.UploadPretreatment;
 import org.dromara.x.file.storage.core.copy.CopyPretreatment;
+import org.dromara.x.file.storage.core.get.*;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
 import org.dromara.x.file.storage.core.platform.FileStorage;
-import org.dromara.x.file.storage.core.platform.MultipartUploadSupportInfo;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.recorder.FileRecorder;
 import org.dromara.x.file.storage.core.tika.ContentTypeDetect;
 import org.dromara.x.file.storage.core.upload.*;
+import org.dromara.x.file.storage.core.upload.MultipartUploadSupportInfo;
 
 /**
  * 文件服务切面接口，用来干预文件上传，删除等
@@ -91,6 +94,27 @@ default FilePartInfoList listParts(ListPartsAspectChain chain, ListPartsPretreat
         return chain.next(pre, fileStorage);
     }
 
+    /**
+     * 是否支持列举文件
+     */
+    default ListFilesSupportInfo isSupportListFiles(IsSupportListFilesAspectChain chain, FileStorage fileStorage) {
+        return chain.next(fileStorage);
+    }
+
+    /**
+     * 列举文件
+     */
+    default ListFilesResult listFiles(ListFilesAspectChain chain, ListFilesPretreatment pre, FileStorage fileStorage) {
+        return chain.next(pre, fileStorage);
+    }
+
+    /**
+     * 获取文件
+     */
+    default RemoteFileInfo getFile(GetFileAspectChain chain, GetFilePretreatment pre, FileStorage fileStorage) {
+        return chain.next(pre, fileStorage);
+    }
+
     /**
      * 删除文件，成功返回 true
      */
@@ -132,9 +156,9 @@ default boolean isSupportPresignedUrlAround(IsSupportPresignedUrlAspectChain cha
     /**
      * 对文件生成可以签名访问的 URL，无法生成则返回 null
      */
-    default String generatePresignedUrlAround(
-            GeneratePresignedUrlAspectChain chain, FileInfo fileInfo, Date expiration, FileStorage fileStorage) {
-        return chain.next(fileInfo, expiration, fileStorage);
+    default GeneratePresignedUrlResult generatePresignedUrlAround(
+            GeneratePresignedUrlAspectChain chain, GeneratePresignedUrlPretreatment pre, FileStorage fileStorage) {
+        return chain.next(pre, fileStorage);
     }
 
     /**
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GeneratePresignedUrlAspectChain.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GeneratePresignedUrlAspectChain.java
index 6eace72e..754c93f4 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GeneratePresignedUrlAspectChain.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GeneratePresignedUrlAspectChain.java
@@ -1,11 +1,11 @@
 package org.dromara.x.file.storage.core.aspect;
 
-import java.util.Date;
 import java.util.Iterator;
 import lombok.Getter;
 import lombok.Setter;
-import org.dromara.x.file.storage.core.FileInfo;
 import org.dromara.x.file.storage.core.platform.FileStorage;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 
 /**
  * 对文件生成可以签名访问的 URL 的切面调用链
@@ -26,11 +26,11 @@ public GeneratePresignedUrlAspectChain(
     /**
      * 调用下一个切面
      */
-    public String next(FileInfo fileInfo, Date expiration, FileStorage fileStorage) {
+    public GeneratePresignedUrlResult next(GeneratePresignedUrlPretreatment pre, FileStorage fileStorage) {
         if (aspectIterator.hasNext()) { // 还有下一个
-            return aspectIterator.next().generatePresignedUrlAround(this, fileInfo, expiration, fileStorage);
+            return aspectIterator.next().generatePresignedUrlAround(this, pre, fileStorage);
         } else {
-            return callback.run(fileInfo, expiration, fileStorage);
+            return callback.run(pre, fileStorage);
         }
     }
 }
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GeneratePresignedUrlAspectChainCallback.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GeneratePresignedUrlAspectChainCallback.java
index c6e13846..78e1f8c1 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GeneratePresignedUrlAspectChainCallback.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GeneratePresignedUrlAspectChainCallback.java
@@ -1,12 +1,12 @@
 package org.dromara.x.file.storage.core.aspect;
 
-import java.util.Date;
-import org.dromara.x.file.storage.core.FileInfo;
 import org.dromara.x.file.storage.core.platform.FileStorage;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 
 /**
  * 对文件生成可以签名访问的 URL 切面调用链结束回调
  */
 public interface GeneratePresignedUrlAspectChainCallback {
-    String run(FileInfo fileInfo, Date expiration, FileStorage fileStorage);
+    GeneratePresignedUrlResult run(GeneratePresignedUrlPretreatment pre, FileStorage fileStorage);
 }
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GetFileAspectChain.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GetFileAspectChain.java
new file mode 100644
index 00000000..ac4b687c
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GetFileAspectChain.java
@@ -0,0 +1,35 @@
+package org.dromara.x.file.storage.core.aspect;
+
+import java.util.Iterator;
+import lombok.Getter;
+import lombok.Setter;
+import org.dromara.x.file.storage.core.get.GetFilePretreatment;
+import org.dromara.x.file.storage.core.get.RemoteFileInfo;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 获取文件的切面调用链
+ */
+@Getter
+@Setter
+public class GetFileAspectChain {
+
+    private GetFileAspectChainCallback callback;
+    private Iterator<FileStorageAspect> aspectIterator;
+
+    public GetFileAspectChain(Iterable<FileStorageAspect> aspects, GetFileAspectChainCallback callback) {
+        this.aspectIterator = aspects.iterator();
+        this.callback = callback;
+    }
+
+    /**
+     * 调用下一个切面
+     */
+    public RemoteFileInfo next(GetFilePretreatment pre, FileStorage fileStorage) {
+        if (aspectIterator.hasNext()) { // 还有下一个
+            return aspectIterator.next().getFile(this, pre, fileStorage);
+        } else {
+            return callback.run(pre, fileStorage);
+        }
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GetFileAspectChainCallback.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GetFileAspectChainCallback.java
new file mode 100644
index 00000000..1773f821
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/GetFileAspectChainCallback.java
@@ -0,0 +1,12 @@
+package org.dromara.x.file.storage.core.aspect;
+
+import org.dromara.x.file.storage.core.get.GetFilePretreatment;
+import org.dromara.x.file.storage.core.get.RemoteFileInfo;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 获取文件切面调用链结束回调
+ */
+public interface GetFileAspectChainCallback {
+    RemoteFileInfo run(GetFilePretreatment pre, FileStorage fileStorage);
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportListFilesAspectChain.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportListFilesAspectChain.java
new file mode 100644
index 00000000..b9327a3d
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportListFilesAspectChain.java
@@ -0,0 +1,35 @@
+package org.dromara.x.file.storage.core.aspect;
+
+import java.util.Iterator;
+import lombok.Getter;
+import lombok.Setter;
+import org.dromara.x.file.storage.core.get.ListFilesSupportInfo;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 是否支持手动分片上传的切面调用链
+ */
+@Getter
+@Setter
+public class IsSupportListFilesAspectChain {
+
+    private IsSupportListFilesChainCallback callback;
+    private Iterator<FileStorageAspect> aspectIterator;
+
+    public IsSupportListFilesAspectChain(
+            Iterable<FileStorageAspect> aspects, IsSupportListFilesChainCallback callback) {
+        this.aspectIterator = aspects.iterator();
+        this.callback = callback;
+    }
+
+    /**
+     * 调用下一个切面
+     */
+    public ListFilesSupportInfo next(FileStorage fileStorage) {
+        if (aspectIterator.hasNext()) { // 还有下一个
+            return aspectIterator.next().isSupportListFiles(this, fileStorage);
+        } else {
+            return callback.run(fileStorage);
+        }
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportListFilesChainCallback.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportListFilesChainCallback.java
new file mode 100644
index 00000000..b127149f
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportListFilesChainCallback.java
@@ -0,0 +1,11 @@
+package org.dromara.x.file.storage.core.aspect;
+
+import org.dromara.x.file.storage.core.get.ListFilesSupportInfo;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 是否支持手动分片上传的切面调用链结束回调
+ */
+public interface IsSupportListFilesChainCallback {
+    ListFilesSupportInfo run(FileStorage fileStorage);
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportMultipartUploadAspectChain.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportMultipartUploadAspectChain.java
index 78794dbf..8613fd45 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportMultipartUploadAspectChain.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportMultipartUploadAspectChain.java
@@ -4,7 +4,7 @@
 import lombok.Getter;
 import lombok.Setter;
 import org.dromara.x.file.storage.core.platform.FileStorage;
-import org.dromara.x.file.storage.core.platform.MultipartUploadSupportInfo;
+import org.dromara.x.file.storage.core.upload.MultipartUploadSupportInfo;
 
 /**
  * 是否支持手动分片上传的切面调用链
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportMultipartUploadChainCallback.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportMultipartUploadChainCallback.java
index 1f12aa6a..db39ed97 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportMultipartUploadChainCallback.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/IsSupportMultipartUploadChainCallback.java
@@ -1,7 +1,7 @@
 package org.dromara.x.file.storage.core.aspect;
 
 import org.dromara.x.file.storage.core.platform.FileStorage;
-import org.dromara.x.file.storage.core.platform.MultipartUploadSupportInfo;
+import org.dromara.x.file.storage.core.upload.MultipartUploadSupportInfo;
 
 /**
  * 是否支持手动分片上传的切面调用链结束回调
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/ListFilesAspectChain.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/ListFilesAspectChain.java
new file mode 100644
index 00000000..64f53888
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/ListFilesAspectChain.java
@@ -0,0 +1,35 @@
+package org.dromara.x.file.storage.core.aspect;
+
+import java.util.Iterator;
+import lombok.Getter;
+import lombok.Setter;
+import org.dromara.x.file.storage.core.get.ListFilesPretreatment;
+import org.dromara.x.file.storage.core.get.ListFilesResult;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 列举文件的切面调用链
+ */
+@Getter
+@Setter
+public class ListFilesAspectChain {
+
+    private ListFilesAspectChainCallback callback;
+    private Iterator<FileStorageAspect> aspectIterator;
+
+    public ListFilesAspectChain(Iterable<FileStorageAspect> aspects, ListFilesAspectChainCallback callback) {
+        this.aspectIterator = aspects.iterator();
+        this.callback = callback;
+    }
+
+    /**
+     * 调用下一个切面
+     */
+    public ListFilesResult next(ListFilesPretreatment pre, FileStorage fileStorage) {
+        if (aspectIterator.hasNext()) { // 还有下一个
+            return aspectIterator.next().listFiles(this, pre, fileStorage);
+        } else {
+            return callback.run(pre, fileStorage);
+        }
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/ListFilesAspectChainCallback.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/ListFilesAspectChainCallback.java
new file mode 100644
index 00000000..f1b0e5b2
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/aspect/ListFilesAspectChainCallback.java
@@ -0,0 +1,12 @@
+package org.dromara.x.file.storage.core.aspect;
+
+import org.dromara.x.file.storage.core.get.ListFilesPretreatment;
+import org.dromara.x.file.storage.core.get.ListFilesResult;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 列举文件切面调用链结束回调
+ */
+public interface ListFilesAspectChainCallback {
+    ListFilesResult run(ListFilesPretreatment pre, FileStorage fileStorage);
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/constant/Constant.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/constant/Constant.java
index d4b239b8..133f2374 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/constant/Constant.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/constant/Constant.java
@@ -185,4 +185,21 @@ interface MessageDigest {
             String SHA512 = "SHA-512";
         }
     }
+
+    /**
+     * 生成预签名 URL
+     */
+    interface GeneratePresignedUrl {
+        /**
+         * HTTP 请求方法
+         */
+        interface Method {
+            String GET = "GET";
+            String PUT = "PUT";
+            String POST = "POST";
+            String DELETE = "DELETE";
+            String HEAD = "HEAD";
+            String OPTIONS = "OPTIONS";
+        }
+    }
 }
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/exception/Check.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/exception/Check.java
index 2fd24a34..8d04d518 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/exception/Check.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/exception/Check.java
@@ -5,7 +5,10 @@
 import org.dromara.x.file.storage.core.FileInfo;
 import org.dromara.x.file.storage.core.UploadPretreatment;
 import org.dromara.x.file.storage.core.copy.CopyPretreatment;
+import org.dromara.x.file.storage.core.get.GetFilePretreatment;
+import org.dromara.x.file.storage.core.get.ListFilesPretreatment;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
 import org.dromara.x.file.storage.core.upload.InitiateMultipartUploadPretreatment;
 
 /**
@@ -246,4 +249,35 @@ public static void listParts(FileInfo fileInfo) {
             throw new FileStorageRuntimeException("手动分片上传-列举已上传的分片失败，请在 FileInfo 中传入 filename 参数");
         if (fileInfo.getUploadId() == null) throw new RuntimeException("手动分片上传-列举已上传的分片失败，请在 FileInfo 中传入 uploadId 参数");
     }
+
+    /**
+     * 列举文件时，检查文件信息相关参数，如果缺少则抛出异常
+     * @param pre 列举文件预处理器
+     */
+    public static void listFiles(ListFilesPretreatment pre) {
+        if (pre.getPlatform() == null) throw new FileStorageRuntimeException("列举文件失败，请传入 platform 参数");
+        if (pre.getPath() == null) throw new FileStorageRuntimeException("列举文件失败，请传入 path 参数");
+        if (pre.getFilenamePrefix() == null) throw new FileStorageRuntimeException("列举文件失败，请传入 filenamePrefix 参数");
+    }
+
+    /**
+     * 获取文件时，检查文件信息相关参数，如果缺少则抛出异常
+     * @param pre 列举文件预处理器
+     */
+    public static void getFile(GetFilePretreatment pre) {
+        if (pre.getPlatform() == null) throw new FileStorageRuntimeException("获取文件失败，请传入 platform 参数");
+        if (pre.getPath() == null) throw new FileStorageRuntimeException("获取文件失败，请传入 path 参数");
+        if (pre.getFilename() == null) throw new FileStorageRuntimeException("获取文件失败，请传入 filename 参数");
+        // if (pre.getUrl() == null) throw new FileStorageRuntimeException("获取文件失败，请传入 url 参数");
+    }
+
+    /**
+     * 生成预签名 URL 时，检查文件信息相关参数，如果缺少则抛出异常
+     * @param pre 生成预签名 URL 预处理器
+     */
+    public static void generatePresignedUrl(GeneratePresignedUrlPretreatment pre) {
+        if (pre.getPlatform() == null) throw new FileStorageRuntimeException("生成预签名 URL 失败，请传入 platform 参数");
+        if (pre.getExpiration() == null) throw new FileStorageRuntimeException("生成预签名 URL 失败，请传入 expiration 参数");
+        if (pre.getMethod() == null) throw new FileStorageRuntimeException("生成预签名 URL 失败，请传入 method 参数");
+    }
 }
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/exception/ExceptionFactory.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/exception/ExceptionFactory.java
index 74082825..f7c644d1 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/exception/ExceptionFactory.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/exception/ExceptionFactory.java
@@ -1,7 +1,11 @@
 package org.dromara.x.file.storage.core.exception;
 
+import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.util.StrUtil;
 import org.dromara.x.file.storage.core.FileInfo;
+import org.dromara.x.file.storage.core.get.GetFilePretreatment;
+import org.dromara.x.file.storage.core.get.ListFilesPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
 
 /**
  * 异常工厂，用于生成各种常用异常，主要用于存储平台的实现类中
@@ -21,8 +25,11 @@ public class ExceptionFactory {
     public static final String COMPLETE_MULTIPART_UPLOAD_MESSAGE_FORMAT = "手动文件分片上传-完成失败！platform：{}，fileInfo：{}";
     public static final String ABORT_MULTIPART_UPLOAD_MESSAGE_FORMAT = "手动文件分片上传-取消失败！platform：{}，fileInfo：{}";
     public static final String LIST_PARTS_MESSAGE_FORMAT = "手动文件分片上传-列举已上传的分片失败！platform：{}，fileInfo：{}";
+    public static final String LIST_FILES_MESSAGE_FORMAT =
+            "列举文件失败！platform：{}，basePath：{}，path：{}，filenamePrefix：{}，maxFiles：{}，marker：{}";
+    public static final String GET_FILE_MESSAGE_FORMAT = "获取文件失败！platform：{}，basePath：{}，path：{}，filename：{}，url：{}";
     public static final String UNRECOGNIZED_ACL_MESSAGE_FORMAT = "无法识别此 ACL！platform：{}，ACL：{}";
-    public static final String GENERATE_PRESIGNED_URL_MESSAGE_FORMAT = "对文件生成可以签名访问的 URL 失败！platform：{}，fileInfo：{}";
+    public static final String GENERATE_PRESIGNED_URL_MESSAGE_FORMAT = "生成预签名 URL 失败！{}";
     public static final String GENERATE_TH_PRESIGNED_URL_MESSAGE_FORMAT =
             "对缩略图文件生成可以签名访问的 URL 失败！platform：{}，fileInfo：{}";
     public static final String SET_FILE_ACL_MESSAGE_FORMAT = "设置文件的 ACL 失败！platform：{}，fileInfo：{}，ACL：{}";
@@ -67,7 +74,7 @@ public class ExceptionFactory {
      */
     public static FileStorageRuntimeException upload(FileInfo fileInfo, String platform, Exception e) {
         return new FileStorageRuntimeException(
-                StrUtil.format(UPLOAD_MESSAGE_FORMAT, fileInfo.getOriginalFilename(), platform), e);
+                StrUtil.format(UPLOAD_MESSAGE_FORMAT, platform, fileInfo.getOriginalFilename()), e);
     }
 
     /**
@@ -179,6 +186,45 @@ public static FileStorageRuntimeException listParts(FileInfo fileInfo, String pl
         return new FileStorageRuntimeException(StrUtil.format(LIST_PARTS_MESSAGE_FORMAT, platform, fileInfo), e);
     }
 
+    /**
+     * 列举文件
+     * @param pre 预处理器
+     * @param basePath 基础路径
+     * @param e 源异常
+     * @return {@link FileStorageRuntimeException}
+     */
+    public static FileStorageRuntimeException listFiles(ListFilesPretreatment pre, String basePath, Exception e) {
+        return new FileStorageRuntimeException(
+                StrUtil.format(
+                        LIST_FILES_MESSAGE_FORMAT,
+                        pre.getPlatform(),
+                        basePath,
+                        pre.getPath(),
+                        pre.getFilenamePrefix(),
+                        pre.getMaxFiles(),
+                        pre.getMarker()),
+                e);
+    }
+
+    /**
+     * 获取文件
+     * @param pre 预处理器
+     * @param basePath 基础路径
+     * @param e 源异常
+     * @return {@link FileStorageRuntimeException}
+     */
+    public static FileStorageRuntimeException getFile(GetFilePretreatment pre, String basePath, Exception e) {
+        return new FileStorageRuntimeException(
+                StrUtil.format(
+                        GET_FILE_MESSAGE_FORMAT,
+                        pre.getPlatform(),
+                        basePath,
+                        pre.getPath(),
+                        pre.getFilename(),
+                        pre.getUrl()),
+                e);
+    }
+
     /**
      * 无法识别此 ACL 异常
      * @param acl ALC（访问控制列表）
@@ -189,6 +235,17 @@ public static FileStorageRuntimeException unrecognizedAcl(Object acl, String pla
         return new FileStorageRuntimeException(StrUtil.format(UNRECOGNIZED_ACL_MESSAGE_FORMAT, platform, acl));
     }
 
+    /**
+     * 生成预签名 URL 异常
+     * @param pre 生成预签名 URL 预处理器
+     * @return {@link FileStorageRuntimeException}
+     */
+    public static FileStorageRuntimeException generatePresignedUrl(GeneratePresignedUrlPretreatment pre, Exception e) {
+        return new FileStorageRuntimeException(
+                StrUtil.format(GENERATE_PRESIGNED_URL_MESSAGE_FORMAT, BeanUtil.beanToMap(pre, "fileStorageService")),
+                e);
+    }
+
     /**
      * 对文件生成可以签名访问的 URL 异常
      * @param fileInfo 文件信息
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/GetFileActuator.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/GetFileActuator.java
new file mode 100644
index 00000000..c1608a11
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/GetFileActuator.java
@@ -0,0 +1,45 @@
+package org.dromara.x.file.storage.core.get;
+
+import java.util.HashMap;
+import java.util.List;
+import org.dromara.x.file.storage.core.FileStorageService;
+import org.dromara.x.file.storage.core.aspect.FileStorageAspect;
+import org.dromara.x.file.storage.core.aspect.GetFileAspectChain;
+import org.dromara.x.file.storage.core.exception.Check;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 获取文件执行器
+ */
+public class GetFileActuator {
+    private final FileStorageService fileStorageService;
+    private final GetFilePretreatment pre;
+
+    public GetFileActuator(GetFilePretreatment pre) {
+        this.pre = pre;
+        this.fileStorageService = pre.getFileStorageService();
+    }
+
+    /**
+     * 执行获取文件
+     */
+    public RemoteFileInfo execute() {
+        return execute(fileStorageService.getFileStorageVerify(pre.getPlatform()), fileStorageService.getAspectList());
+    }
+
+    /**
+     * 执行获取文件
+     */
+    public RemoteFileInfo execute(FileStorage fileStorage, List<FileStorageAspect> aspectList) {
+        Check.getFile(pre);
+        return new GetFileAspectChain(aspectList, (_pre, _fileStorage) -> {
+                    RemoteFileInfo info = _fileStorage.getFile(_pre);
+                    if (info != null) {
+                        if (info.getMetadata() == null) info.setMetadata(new HashMap<>());
+                        if (info.getUserMetadata() == null) info.setUserMetadata(new HashMap<>());
+                    }
+                    return info;
+                })
+                .next(pre, fileStorage);
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/GetFilePretreatment.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/GetFilePretreatment.java
new file mode 100644
index 00000000..622b1773
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/GetFilePretreatment.java
@@ -0,0 +1,107 @@
+package org.dromara.x.file.storage.core.get;
+
+import java.util.List;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.dromara.x.file.storage.core.FileStorageService;
+import org.dromara.x.file.storage.core.aspect.FileStorageAspect;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 获取文件预处理器
+ */
+@Getter
+@Setter
+@Accessors(chain = true)
+public class GetFilePretreatment {
+    /**
+     * 文件存储服务类
+     */
+    private FileStorageService fileStorageService;
+    /**
+     * 存储平台名称
+     */
+    private String platform;
+    /**
+     * 路径，需要与上传时传入的路径保持一致
+     */
+    private String path = "";
+    /**
+     * 文件名
+     */
+    private String filename = "";
+    /**
+     * 文件访问地址，仅用于兼容 FastDFS 的 URL 模式
+     */
+    private String url = "";
+
+    /**
+     * 如果条件为 true 则：设置文件存储服务类
+     * @param flag 条件
+     * @param fileStorageService 文件存储服务类
+     * @return 获取文件预处理器
+     */
+    public GetFilePretreatment setFileStorageService(boolean flag, FileStorageService fileStorageService) {
+        if (flag) setFileStorageService(fileStorageService);
+        return this;
+    }
+
+    /**
+     * 设置存储平台名称（如果条件为 true）
+     * @param flag 条件
+     * @param platform 存储平台名称
+     * @return 获取文件预处理器
+     */
+    public GetFilePretreatment setPlatform(boolean flag, String platform) {
+        if (flag) setPlatform(platform);
+        return this;
+    }
+
+    /**
+     * 设置路径，需要与上传时传入的路径保持一致（如果条件为 true）
+     * @param flag 条件
+     * @param path 文件访问地址
+     * @return 获取文件预处理器
+     */
+    public GetFilePretreatment setPath(boolean flag, String path) {
+        if (flag) setPath(path);
+        return this;
+    }
+
+    /**
+     * 设置文件名（如果条件为 true）
+     * @param flag 条件
+     * @param filename 文件名
+     * @return 获取文件预处理器
+     */
+    public GetFilePretreatment setFilename(boolean flag, String filename) {
+        if (flag) setFilename(filename);
+        return this;
+    }
+
+    /**
+     * 设置文件访问地址（如果条件为 true）
+     * @param flag 条件
+     * @param url 文件访问地址
+     * @return 获取文件预处理器
+     */
+    public GetFilePretreatment setUrl(boolean flag, String url) {
+        if (flag) setUrl(url);
+        return this;
+    }
+
+    /**
+     * 执行获取文件
+     */
+    public RemoteFileInfo getFile() {
+        return new GetFileActuator(this).execute();
+    }
+
+    /**
+     * 执行获取文件，此方法仅限内部使用
+     */
+    public RemoteFileInfo getFile(FileStorage fileStorage, List<FileStorageAspect> aspectList) {
+        return new GetFileActuator(this).execute(fileStorage, aspectList);
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesActuator.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesActuator.java
new file mode 100644
index 00000000..0a308b16
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesActuator.java
@@ -0,0 +1,88 @@
+package org.dromara.x.file.storage.core.get;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import org.dromara.x.file.storage.core.FileStorageService;
+import org.dromara.x.file.storage.core.aspect.FileStorageAspect;
+import org.dromara.x.file.storage.core.aspect.ListFilesAspectChain;
+import org.dromara.x.file.storage.core.exception.Check;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 列举文件执行器
+ */
+public class ListFilesActuator {
+    private final FileStorageService fileStorageService;
+    private final ListFilesPretreatment pre;
+
+    public ListFilesActuator(ListFilesPretreatment pre) {
+        this.pre = pre;
+        this.fileStorageService = pre.getFileStorageService();
+    }
+
+    /**
+     * 执行列举文件
+     */
+    public ListFilesResult execute() {
+        return execute(fileStorageService.getFileStorageVerify(pre.getPlatform()), fileStorageService.getAspectList());
+    }
+
+    /**
+     * 执行列举文件
+     */
+    public ListFilesResult execute(FileStorage fileStorage, List<FileStorageAspect> aspectList) {
+        Check.listFiles(pre);
+        return new ListFilesAspectChain(aspectList, (_pre, _fileStorage) -> {
+                    _pre = new ListFilesPretreatment(_pre);
+                    ListFilesSupportInfo supportInfo = fileStorageService.isSupportListFiles(_fileStorage);
+
+                    // 获取对应存储平台每次获取的最大文件数，对象存储一般是 1000
+                    Integer supportMaxFiles = supportInfo.getSupportMaxFiles();
+
+                    // 如果超出范围则直接取最大值
+                    if (_pre.getMaxFiles() == null || _pre.getMaxFiles() < 1) {
+                        _pre.setMaxFiles(supportMaxFiles);
+                    }
+                    ListFilesResult result;
+                    // 如果要返回的最大文件数量为 null 或小于等于支持的最大文件数量，则直接调用，否则分多次调用后拼接成一个结果
+                    if (supportMaxFiles == null || _pre.getMaxFiles() <= supportMaxFiles) {
+                        result = _fileStorage.listFiles(_pre);
+                    } else {
+                        result = new ListFilesResult();
+                        result.setDirList(new ArrayList<>());
+                        result.setFileList(new ArrayList<>());
+                        result.setPlatform(_pre.getPlatform());
+                        result.setPath(_pre.getPath());
+                        result.setFilenamePrefix(_pre.getFilenamePrefix());
+                        result.setMaxFiles(_pre.getMaxFiles());
+                        result.setMarker(_pre.getMarker());
+
+                        Integer residueFileNum = _pre.getMaxFiles();
+                        String marker = _pre.getMarker();
+                        while (true) {
+                            ListFilesPretreatment tempPre = new ListFilesPretreatment(_pre);
+                            tempPre.setMaxFiles(residueFileNum <= supportMaxFiles ? residueFileNum : supportMaxFiles);
+                            tempPre.setMarker(marker);
+                            ListFilesResult tempList = _fileStorage.listFiles(tempPre);
+                            result.getFileList().addAll(tempList.getFileList());
+                            result.getDirList().addAll(tempList.getDirList());
+                            result.setBasePath(tempList.getBasePath());
+                            residueFileNum = residueFileNum - supportMaxFiles;
+                            marker = tempList.getNextMarker();
+                            if (residueFileNum <= 0 || !tempList.getIsTruncated()) {
+                                result.setNextMarker(tempList.getNextMarker());
+                                result.setIsTruncated(tempList.getIsTruncated());
+                                break;
+                            }
+                        }
+                    }
+                    for (RemoteFileInfo info : result.getFileList()) {
+                        if (info.getMetadata() == null) info.setMetadata(new HashMap<>());
+                        if (info.getUserMetadata() == null) info.setUserMetadata(new HashMap<>());
+                    }
+                    return result;
+                })
+                .next(pre, fileStorage);
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesPretreatment.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesPretreatment.java
new file mode 100644
index 00000000..d6a132f3
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesPretreatment.java
@@ -0,0 +1,137 @@
+package org.dromara.x.file.storage.core.get;
+
+import java.util.List;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.dromara.x.file.storage.core.FileStorageService;
+import org.dromara.x.file.storage.core.aspect.FileStorageAspect;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 列举文件预处理器
+ */
+@Getter
+@Setter
+@Accessors(chain = true)
+@NoArgsConstructor
+public class ListFilesPretreatment {
+    /**
+     * 文件存储服务类
+     */
+    private FileStorageService fileStorageService;
+    /**
+     * 存储平台名称
+     */
+    private String platform;
+    /**
+     * 路径，需要与上传时传入的路径保持一致
+     */
+    private String path = "";
+    /**
+     * 文件名前缀
+     */
+    private String filenamePrefix = "";
+    /**
+     * 要列举的最大文件数量，这里默认最大值表示全部文件
+     */
+    private Integer maxFiles = Integer.MAX_VALUE;
+    /**
+     * 表示待列举文件的起始位置，从该标识符以后按文件名的字典顺序返回对象列表，默认从头开始
+     */
+    private String marker;
+
+    /**
+     * 如果条件为 true 则：设置文件存储服务类
+     * @param flag 条件
+     * @param fileStorageService 文件存储服务类
+     * @return 列举文件预处理器
+     */
+    public ListFilesPretreatment setFileStorageService(boolean flag, FileStorageService fileStorageService) {
+        if (flag) setFileStorageService(fileStorageService);
+        return this;
+    }
+
+    /**
+     * 设置存储平台名称（如果条件为 true）
+     * @param flag 条件
+     * @param platform 存储平台名称
+     * @return 列举文件预处理器
+     */
+    public ListFilesPretreatment setPlatform(boolean flag, String platform) {
+        if (flag) setPlatform(platform);
+        return this;
+    }
+
+    /**
+     * 设置路径，需要与上传时传入的路径保持一致（如果条件为 true）
+     * @param flag 条件
+     * @param path 文件访问地址
+     * @return 列举文件预处理器
+     */
+    public ListFilesPretreatment setPath(boolean flag, String path) {
+        if (flag) setPath(path);
+        return this;
+    }
+
+    /**
+     * 设置文件名前缀（如果条件为 true）
+     * @param flag 条件
+     * @param filenamePrefix 文件名前缀
+     * @return 列举文件预处理器
+     */
+    public ListFilesPretreatment setFilenamePrefix(boolean flag, String filenamePrefix) {
+        if (flag) setFilenamePrefix(filenamePrefix);
+        return this;
+    }
+
+    /**
+     * 设置要列举的最大文件数量，这里默认最大值表示全部文件（如果条件为 true）
+     * @param flag 条件
+     * @param maxFiles 要列举的最大文件数量，这里默认最大值表示全部文件
+     * @return 列举文件预处理器
+     */
+    public ListFilesPretreatment setMaxFiles(boolean flag, Integer maxFiles) {
+        if (flag) setMaxFiles(maxFiles);
+        return this;
+    }
+
+    /**
+     * 设置表示待列举文件的起始位置，从该标识符以后按文件名的字典顺序返回对象列表，默认从头开始（如果条件为 true）
+     * @param flag 条件
+     * @param marker 表示待列举文件的起始位置，从该标识符以后按文件名的字典顺序返回对象列表，默认从头开始
+     * @return 列举文件预处理器
+     */
+    public ListFilesPretreatment setMarker(boolean flag, String marker) {
+        if (flag) setMarker(marker);
+        return this;
+    }
+
+    /**
+     * 执行列举文件
+     */
+    public ListFilesResult listFiles() {
+        return new ListFilesActuator(this).execute();
+    }
+
+    /**
+     * 执行列举文件，此方法仅限内部使用
+     */
+    public ListFilesResult listFiles(FileStorage fileStorage, List<FileStorageAspect> aspectList) {
+        return new ListFilesActuator(this).execute(fileStorage, aspectList);
+    }
+
+    /**
+     * 通过已有的预处理来创建新的预处理器
+     * @param pre 已有的预处理器
+     */
+    public ListFilesPretreatment(ListFilesPretreatment pre) {
+        this.fileStorageService = pre.getFileStorageService();
+        this.platform = pre.getPlatform();
+        this.path = pre.getPath();
+        this.filenamePrefix = pre.getFilenamePrefix();
+        this.maxFiles = pre.maxFiles;
+        this.marker = pre.getMarker();
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesResult.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesResult.java
new file mode 100644
index 00000000..c4703df9
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesResult.java
@@ -0,0 +1,55 @@
+package org.dromara.x.file.storage.core.get;
+
+import java.util.List;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+/**
+ * 文件信息列举结果
+ */
+@Data
+@NoArgsConstructor
+@Accessors(chain = true)
+public class ListFilesResult {
+    /**
+     * 目录列表
+     */
+    private List<RemoteDirInfo> dirList;
+    /**
+     * 文件列表
+     */
+    private List<RemoteFileInfo> fileList;
+    /**
+     * 存储平台名称
+     */
+    private String platform;
+    /**
+     * 基础存储路径
+     */
+    private String basePath;
+    /**
+     * 路径，需要与上传时传入的路径保持一致
+     */
+    private String path = "";
+    /**
+     * 文件名前缀
+     */
+    private String filenamePrefix = "";
+    /**
+     * 本次列举的最大文件数量
+     */
+    private Integer maxFiles;
+    /**
+     * 列表是否被截断，就是当前目录下还有其它文件超出最大文件数量未被列举
+     */
+    private Boolean isTruncated;
+    /**
+     * 本次列举的起始位置
+     */
+    private String marker;
+    /**
+     * 下次列举的起始位置
+     */
+    private String nextMarker;
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesSupportInfo.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesSupportInfo.java
new file mode 100644
index 00000000..7977dc15
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/ListFilesSupportInfo.java
@@ -0,0 +1,39 @@
+package org.dromara.x.file.storage.core.get;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+/**
+ * 列举文件支持信息
+ */
+@Data
+@Accessors(chain = true)
+@NoArgsConstructor
+@AllArgsConstructor
+public class ListFilesSupportInfo {
+    /**
+     * 是否支持列举文件，正常情况下判断此参数就行了
+     */
+    private Boolean isSupport;
+
+    /**
+     * 每次获取的最大文件数，对象存储一般是 1000
+     */
+    private Integer supportMaxFiles;
+
+    /**
+     * 不支持列举文件
+     */
+    public static ListFilesSupportInfo notSupport() {
+        return new ListFilesSupportInfo(false, null);
+    }
+
+    /**
+     * 支持全部的列举文件功能
+     */
+    public static ListFilesSupportInfo supportAll() {
+        return new ListFilesSupportInfo(true, 1000);
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/RemoteDirInfo.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/RemoteDirInfo.java
new file mode 100644
index 00000000..ceb873db
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/RemoteDirInfo.java
@@ -0,0 +1,152 @@
+package org.dromara.x.file.storage.core.get;
+
+import com.azure.storage.blob.implementation.models.BlobPrefixInternal;
+import com.github.sardine.DavResource;
+import com.google.cloud.storage.Blob;
+import com.jcraft.jsch.ChannelSftp;
+import io.minio.messages.Prefix;
+import java.io.File;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import org.apache.commons.net.ftp.FTPFile;
+import org.dromara.x.file.storage.core.util.Tools;
+import org.json.JSONObject;
+
+/**
+ * 远程目录信息
+ */
+@Data
+@NoArgsConstructor
+@Accessors(chain = true)
+public class RemoteDirInfo {
+    /**
+     * 存储平台
+     */
+    private String platform;
+    /**
+     * 基础存储路径
+     */
+    private String basePath;
+    /**
+     * 存储路径
+     */
+    private String path;
+    /**
+     * 目录名称
+     */
+    private String name;
+    /**
+     * 原始数据
+     */
+    private Object original;
+
+    /**
+     * 获取原始数据并转换为指定类型
+     */
+    public <T> T getOriginal(Class<T> clazz) {
+        if (original == null) return null;
+        if (clazz.isInstance(original)) {
+            return Tools.cast(original);
+        }
+        return null;
+    }
+
+    /**
+     * 获取阿里云 OSS 存储平台的目录原始数据，失败返回 null，
+     */
+    public String getOriginalAliyunOss() {
+        return getOriginal(String.class);
+    }
+
+    /**
+     * 获取 Amazon S3 存储平台的目录原始数据，失败返回 null，
+     */
+    public String getOriginalAmazonS3() {
+        return getOriginal(String.class);
+    }
+
+    /**
+     * 获取 Azure Blob Storage 存储平台的目录原始数据，失败返回 null，
+     */
+    public BlobPrefixInternal getOriginalAzureBlobStorage() {
+        return getOriginal(BlobPrefixInternal.class);
+    }
+
+    /**
+     * 获取百度云 BOS 存储平台的目录原始数据，失败返回 null，
+     */
+    public String getOriginalBaiduBos() {
+        return getOriginal(String.class);
+    }
+
+    /**
+     * 获取 FTP 存储平台的目录原始数据，失败返回 null
+     */
+    public FTPFile getOriginalFtp() {
+        return getOriginal(FTPFile.class);
+    }
+
+    /**
+     * 获取 Google Cloud Storage 存储平台的目录原始数据，失败返回 null
+     */
+    public Blob getOriginalGoogleCloudStorage() {
+        return getOriginal(Blob.class);
+    }
+
+    /**
+     * 获取华为云 OBS 存储平台的目录原始数据，失败返回 null
+     */
+    public String getOriginalHuaweiObs() {
+        return getOriginal(String.class);
+    }
+
+    /**
+     * 获取本地存储平台（升级版）的目录原始数据，失败返回 null
+     */
+    public File getOriginalLocal() {
+        return getOriginal(File.class);
+    }
+
+    /**
+     * 获取 Minio 存储平台的目录原始数据，失败返回 null，
+     */
+    public Prefix getOriginalMinio() {
+        return getOriginal(Prefix.class);
+    }
+
+    /**
+     * 获取七牛云 Kodo 存储平台的目录原始数据，失败返回 null
+     */
+    public String getOriginalQiniuKodo() {
+        return getOriginal(String.class);
+    }
+
+    /**
+     * 获取 SFTP 存储平台的目录原始数据，失败返回 null
+     */
+    public ChannelSftp.LsEntry getOriginalSftp() {
+        return getOriginal(ChannelSftp.LsEntry.class);
+    }
+
+    /**
+     * 获取腾讯云 COS 存储平台的目录原始数据，失败返回 null，
+     */
+    public String getOriginalTencentCos() {
+        return getOriginal(String.class);
+    }
+
+    /**
+     * 获取又拍云 USS 存储平台的目录原始数据，失败返回 null，
+     */
+    public JSONObject getOriginalUpyunUss() {
+        return getOriginal(JSONObject.class);
+    }
+
+    /**
+     * 获取 WebDAV 存储平台的目录原始数据，失败返回 null
+     */
+    public DavResource getOriginalWebDav() {
+        return getOriginal(DavResource.class);
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/RemoteFileInfo.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/RemoteFileInfo.java
new file mode 100644
index 00000000..f76e5e07
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/get/RemoteFileInfo.java
@@ -0,0 +1,375 @@
+package org.dromara.x.file.storage.core.get;
+
+import cn.hutool.core.map.MapProxy;
+import com.aliyun.oss.model.OSSObject;
+import com.aliyun.oss.model.OSSObjectSummary;
+import com.amazonaws.services.s3.model.S3Object;
+import com.amazonaws.services.s3.model.S3ObjectSummary;
+import com.azure.storage.blob.implementation.models.BlobItemInternal;
+import com.azure.storage.blob.models.BlobProperties;
+import com.baidubce.services.bos.model.BosObject;
+import com.baidubce.services.bos.model.BosObjectSummary;
+import com.github.sardine.DavResource;
+import com.google.cloud.storage.Blob;
+import com.jcraft.jsch.ChannelSftp.LsEntry;
+import com.obs.services.model.ObsObject;
+import com.qcloud.cos.model.COSObject;
+import com.qcloud.cos.model.COSObjectSummary;
+import io.minio.StatObjectResponse;
+import io.minio.messages.Contents;
+import java.io.File;
+import java.util.Date;
+import java.util.Map;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+import okhttp3.Response;
+import org.apache.commons.net.ftp.FTPFile;
+import org.dromara.x.file.storage.core.FileInfo;
+import org.dromara.x.file.storage.core.platform.FastDfsFileStorage.FastDfsFileInfo;
+import org.dromara.x.file.storage.core.util.KebabCaseInsensitiveMap;
+import org.dromara.x.file.storage.core.util.Tools;
+import org.json.JSONObject;
+
+/**
+ * 远程文件信息
+ */
+@Data
+@NoArgsConstructor
+@Accessors(chain = true)
+public class RemoteFileInfo {
+    /**
+     * 存储平台
+     */
+    private String platform;
+    /**
+     * 基础存储路径
+     */
+    private String basePath;
+    /**
+     * 存储路径
+     */
+    private String path;
+    /**
+     * 文件名称
+     */
+    private String filename;
+    /**
+     * 文件访问地址
+     */
+    private String url;
+    /**
+     * 文件大小，单位字节
+     */
+    private Long size;
+    /**
+     * 文件扩展名
+     */
+    private String ext;
+    /**
+     * 文件 ETag，仅部分存储平台支持
+     */
+    private String eTag;
+    /**
+     * Content-Disposition，仅部分存储平台支持
+     */
+    private String contentDisposition;
+    /**
+     * MIME 类型，仅部分存储平台支持
+     */
+    private String contentType;
+    /**
+     * MD5，仅部分存储平台支持
+     */
+    private String contentMd5;
+    /**
+     * 最后修改时间
+     */
+    private Date lastModified;
+    /**
+     * 文件元数据，仅部分存储平台支持
+     */
+    private Map<String, Object> metadata;
+    /**
+     * 文件用户元数据，仅部分存储平台支持
+     */
+    private Map<String, Object> userMetadata;
+    /**
+     * 原始数据
+     */
+    private Object original;
+
+    /**
+     * 获取短横命名风格且不区分大小写的文件元数据，以下方式都获得的值相同，put进入的值也会被覆盖<br>
+     * get("ContentType")<br>
+     * get("Content_Type")<br>
+     * get("HelloWorld_test")<br>
+     * get("Content-Type")<br>
+     * get("contentType")<br>
+     */
+    public MapProxy getKebabCaseInsensitiveMetadata() {
+        if (metadata == null) return null;
+        return new MapProxy(new KebabCaseInsensitiveMap<>(metadata));
+    }
+
+    /**
+     * 获取短横命名风格的文件用户元数据，以下方式都获得的值相同，put进入的值也会被覆盖<br>
+     * get("ContentType")<br>
+     * get("Content_Type")<br>
+     * get("HelloWorld_test")<br>
+     * get("Content-Type")<br>
+     * get("contentType")<br>
+     */
+    public MapProxy getKebabCaseInsensitiveUserMetadata() {
+        if (userMetadata == null) return null;
+        return new MapProxy(new KebabCaseInsensitiveMap<>(userMetadata));
+    }
+
+    /**
+     * 获取原始数据并转换为指定类型
+     */
+    public <T> T getOriginal(Class<T> clazz) {
+        if (original == null) return null;
+        if (clazz.isInstance(original)) {
+            return Tools.cast(original);
+        }
+        return null;
+    }
+
+    /**
+     * 获取阿里云 OSS 存储平台的文件原始数据，失败返回 null，
+     * 仅在获取文件的返回值中使用
+     */
+    public OSSObject getOriginalAliyunOssObject() {
+        return getOriginal(OSSObject.class);
+    }
+
+    /**
+     * 获取阿里云 OSS 存储平台的文件原始数据，失败返回 null，
+     * 仅在列举文件的返回值中使用
+     */
+    public OSSObjectSummary getOriginalAliyunOssObjectSummary() {
+        return getOriginal(OSSObjectSummary.class);
+    }
+
+    /**
+     * 获取 Amazon S3 存储平台的文件原始数据，失败返回 null，
+     * 仅在获取文件的返回值中使用
+     */
+    public S3Object getOriginalAmazonS3Object() {
+        return getOriginal(S3Object.class);
+    }
+
+    /**
+     * 获取 Amazon S3 存储平台的文件原始数据，失败返回 null，
+     * 仅在列举文件的返回值中使用
+     */
+    public S3ObjectSummary getOriginalAmazonS3ObjectSummary() {
+        return getOriginal(S3ObjectSummary.class);
+    }
+
+    /**
+     * 获取 Azure Blob Storage 存储平台的文件原始数据，失败返回 null，
+     * 仅在获取文件的返回值中使用
+     */
+    public BlobProperties getOriginalAzureBlobStorageBlobProperties() {
+        return getOriginal(BlobProperties.class);
+    }
+
+    /**
+     * 获取 Azure Blob Storage 存储平台的文件原始数据，失败返回 null，
+     * 仅在列举文件的返回值中使用
+     */
+    public BlobItemInternal getOriginalAzureBlobStorageBlobItemInternal() {
+        return getOriginal(BlobItemInternal.class);
+    }
+
+    /**
+     * 获取百度云 BOS 存储平台的文件原始数据，失败返回 null，
+     * 仅在获取文件的返回值中使用
+     */
+    public BosObject getOriginalBaiduBosObject() {
+        return getOriginal(BosObject.class);
+    }
+
+    /**
+     * 获取百度云 BOS 存储平台的文件原始数据，失败返回 null，
+     * 仅在列举文件的返回值中使用
+     */
+    public BosObjectSummary getOriginalBaiduBosObjectSummary() {
+        return getOriginal(BosObjectSummary.class);
+    }
+
+    /**
+     * 获取 FastDFS 存储平台的文件原始数据，失败返回 null
+     */
+    public FastDfsFileInfo getOriginalFastDfs() {
+        return getOriginal(FastDfsFileInfo.class);
+    }
+
+    /**
+     * 获取 FTP 存储平台的文件原始数据，失败返回 null
+     */
+    public FTPFile getOriginalFtp() {
+        return getOriginal(FTPFile.class);
+    }
+
+    /**
+     * 获取 Google Cloud Storage 存储平台的文件原始数据，失败返回 null
+     */
+    public Blob getOriginalGoogleCloudStorage() {
+        return getOriginal(Blob.class);
+    }
+
+    /**
+     * 获取华为云 OBS 存储平台的文件原始数据，失败返回 null
+     */
+    public ObsObject getOriginalHuaweiObs() {
+        return getOriginal(ObsObject.class);
+    }
+
+    /**
+     * 获取本地存储平台（升级版）的文件原始数据，失败返回 null
+     */
+    public File getOriginalLocal() {
+        return getOriginal(File.class);
+    }
+
+    /**
+     * 获取 Minio 存储平台的文件原始数据，失败返回 null，
+     * 仅在获取文件的返回值中使用
+     */
+    public StatObjectResponse getOriginalMinioStatObjectResponse() {
+        return getOriginal(StatObjectResponse.class);
+    }
+
+    /**
+     * 获取 Minio 存储平台的文件原始数据，失败返回 null，
+     * 仅在列举文件的返回值中使用
+     */
+    public Contents getOriginalMinioContents() {
+        return getOriginal(Contents.class);
+    }
+
+    /**
+     * 获取七牛云 Kodo 存储平台的文件原始数据，失败返回 null
+     */
+    public com.qiniu.storage.model.FileInfo getOriginalQiniuKodo() {
+        return getOriginal(com.qiniu.storage.model.FileInfo.class);
+    }
+
+    /**
+     * 获取 SFTP 存储平台的文件原始数据，失败返回 null
+     */
+    public LsEntry getOriginalSftp() {
+        return getOriginal(LsEntry.class);
+    }
+
+    /**
+     * 获取腾讯云 COS 存储平台的文件原始数据，失败返回 null，
+     * 仅在获取文件的返回值中使用
+     */
+    public COSObject getOriginalTencentCosObject() {
+        return getOriginal(COSObject.class);
+    }
+
+    /**
+     * 获取腾讯云 COS 存储平台的文件原始数据，失败返回 null，
+     * 仅在列举文件的返回值中使用
+     */
+    public COSObjectSummary getOriginalTencentCosObjectSummary() {
+        return getOriginal(COSObjectSummary.class);
+    }
+
+    /**
+     * 获取又拍云 USS 存储平台的文件原始数据，失败返回 null，
+     * 仅在获取文件的返回值中使用
+     */
+    public Response getOriginalUpyunUssResponse() {
+        return getOriginal(Response.class);
+    }
+
+    /**
+     * 获取又拍云 USS 存储平台的文件原始数据，失败返回 null，
+     * 仅在列举文件的返回值中使用
+     */
+    public JSONObject getOriginalUpyunUssJSONObject() {
+        return getOriginal(JSONObject.class);
+    }
+
+    /**
+     * 获取 WebDAV 存储平台的文件原始数据，失败返回 null
+     */
+    public DavResource getOriginalWebDav() {
+        return getOriginal(DavResource.class);
+    }
+
+    /**
+     * 转换成 FileInfo，注意 createTime 、metadata 及 userMetadata 可能需要自行处理，详情查看下方源码注释
+     * @return 文件信息
+     */
+    public FileInfo toFileInfo() {
+        return toFileInfo(new FileInfo());
+    }
+
+    /**
+     * 转换成 FileInfo，注意 createTime 、metadata 及 userMetadata 可能需要自行处理，详情查看下方源码注释
+     * @param fileInfo 文件信息
+     * @return 文件信息
+     */
+    public FileInfo toFileInfo(FileInfo fileInfo) {
+        fileInfo.setPlatform(platform).setBasePath(basePath).setPath(path).setFilename(filename);
+        fileInfo.setUrl(url).setSize(size).setExt(ext).setContentType(contentType);
+        // 一般情况下 FileInfo 中的 createTime（创建时间）就是 RemoteFileInfo 中的 lastModified（最后修改时间），
+        // 如果有误，可以自行设置
+        fileInfo.setCreateTime(lastModified);
+        // RemoteFileInfo 中的 metadata 元数据值为 Object 类型，FileInfo 中的元数据值为 String 类型，
+        // 目前是将 Object 类型使用 toString() 方法转为 String 类型，应该可以满足大部分情况，如有需要可以自行转换
+        fileInfo.setMetadata(Tools.toStringMap(metadata));
+        fileInfo.setUserMetadata(Tools.toStringMap(userMetadata));
+        return fileInfo;
+    }
+
+    /**
+     * 转换成缩略图 FileInfo，注意 metadata 及 userMetadata 可能需要自行处理，详情查看下方源码注释
+     * @return 文件信息
+     */
+    public FileInfo toFileInfoTh() {
+        return toFileInfo(new FileInfo());
+    }
+
+    /**
+     * 转换成缩略图 FileInfo，注意不含 platform 、 basePath 及 path，如果需要，请使用 toFileInfoThAll() 方法，
+     * 注意 metadata 及 userMetadata 可能需要自行处理，详情查看下方源码注释
+     * @param fileInfo 文件信息
+     * @return 文件信息
+     */
+    public FileInfo toFileInfoTh(FileInfo fileInfo) {
+        fileInfo.setThFilename(filename).setThUrl(url).setThSize(size).setThContentType(contentType);
+        // RemoteFileInfo 中的 metadata 元数据值为 Object 类型，FileInfo 中的元数据值为 String 类型，
+        // 目前是将 Object 类型使用 toString() 方法转为 String 类型，应该可以满足大部分情况，如有需要可以自行转换
+        fileInfo.setThMetadata(Tools.toStringMap(metadata));
+        fileInfo.setThUserMetadata(Tools.toStringMap(userMetadata));
+        return fileInfo;
+    }
+
+    /**
+     * 转换成缩略图 FileInfo，注意 metadata 及 userMetadata 可能需要自行处理，详情查看下方源码注释
+     * @return 文件信息
+     */
+    public FileInfo toFileInfoThAll() {
+        return toFileInfoThAll(new FileInfo());
+    }
+
+    /**
+     * 转换成缩略图 FileInfo，注意 metadata 及 userMetadata 可能需要自行处理，详情查看下方源码注释
+     * @param fileInfo 文件信息
+     * @return 文件信息
+     */
+    public FileInfo toFileInfoThAll(FileInfo fileInfo) {
+        return toFileInfoTh(fileInfo)
+                .setPlatform(platform)
+                .setBasePath(basePath)
+                .setPath(path);
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AliyunOssFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AliyunOssFileStorage.java
index f1986cf7..f7ef1c10 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AliyunOssFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AliyunOssFileStorage.java
@@ -2,15 +2,16 @@
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.io.file.FileNameUtil;
 import cn.hutool.core.util.StrUtil;
+import com.aliyun.oss.HttpMethod;
 import com.aliyun.oss.OSS;
 import com.aliyun.oss.event.ProgressEventType;
 import com.aliyun.oss.model.*;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
+import java.net.URL;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
@@ -26,7 +27,11 @@
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.get.*;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.upload.*;
+import org.dromara.x.file.storage.core.util.Tools;
 
 /**
  * 阿里云 OSS 存储
@@ -268,6 +273,99 @@ public FilePartInfoList listParts(ListPartsPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll();
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        OSS client = getClient();
+        try {
+            ListObjectsRequest request = new ListObjectsRequest(bucketName);
+            request.setMaxKeys(pre.getMaxFiles());
+            request.setMarker(pre.getMarker());
+            request.setDelimiter("/");
+            request.setPrefix(basePath + pre.getPath() + pre.getFilenamePrefix());
+            ObjectListing result = client.listObjects(request);
+            ListFilesResult list = new ListFilesResult();
+
+            list.setDirList(result.getCommonPrefixes().stream()
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(FileNameUtil.getName(item));
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+            list.setFileList(result.getObjectSummaries().stream()
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(FileNameUtil.getName(item.getKey()));
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.getSize());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setETag(item.getETag());
+                        info.setLastModified(item.getLastModified());
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(result.getMaxKeys());
+            list.setIsTruncated(result.isTruncated());
+            list.setMarker(result.getMarker());
+            list.setNextMarker(result.getNextMarker());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        OSS client = getClient();
+        try {
+            OSSObject file;
+            try {
+                file = client.getObject(bucketName, fileKey);
+            } catch (Exception e) {
+                return null;
+            }
+            if (file == null) return null;
+            ObjectMetadata metadata = file.getObjectMetadata();
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(FileNameUtil.getName(file.getKey()));
+            info.setUrl(domain + fileKey);
+            info.setSize(metadata.getContentLength());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setETag(metadata.getETag());
+            info.setContentDisposition(metadata.getContentDisposition());
+            info.setContentType(metadata.getContentType());
+            info.setContentMd5(metadata.getContentMD5());
+            info.setLastModified(metadata.getLastModified());
+            if (metadata.getRawMetadata() != null) info.setMetadata(new HashMap<>(metadata.getRawMetadata()));
+            if (metadata.getUserMetadata() != null) info.setUserMetadata(new HashMap<>(metadata.getUserMetadata()));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     /**
      * 获取文件的访问控制列表
      */
@@ -324,24 +422,24 @@ public boolean isSupportPresignedUrl() {
     }
 
     @Override
-    public String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
-        try {
-            return getClient()
-                    .generatePresignedUrl(bucketName, getFileKey(fileInfo), expiration)
-                    .toString();
-        } catch (Exception e) {
-            throw ExceptionFactory.generatePresignedUrl(fileInfo, platform, e);
-        }
-    }
-
-    @Override
-    public String generateThPresignedUrl(FileInfo fileInfo, Date expiration) {
+    public GeneratePresignedUrlResult generatePresignedUrl(GeneratePresignedUrlPretreatment pre) {
         try {
-            String key = getThFileKey(fileInfo);
-            if (key == null) return null;
-            return getClient().generatePresignedUrl(bucketName, key, expiration).toString();
+            String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+            GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, fileKey);
+            request.setExpiration(pre.getExpiration());
+            request.setMethod(Tools.getEnum(HttpMethod.class, pre.getMethod()));
+            request.setHeaders(new HashMap<>(pre.getHeaders()));
+            request.setUserMetadata(new HashMap<>(pre.getUserMetadata()));
+            HashMap<String, String> queryParam = new HashMap<>(pre.getQueryParams());
+            pre.getResponseHeaders().forEach((k, v) -> queryParam.put("response-" + k.toLowerCase(), v));
+            request.setQueryParameter(queryParam);
+            URL url = getClient().generatePresignedUrl(request);
+            GeneratePresignedUrlResult result = new GeneratePresignedUrlResult(platform, basePath, pre);
+            result.setUrl(url.toString());
+            result.setHeaders(request.getHeaders());
+            return result;
         } catch (Exception e) {
-            throw ExceptionFactory.generateThPresignedUrl(fileInfo, platform, e);
+            throw ExceptionFactory.generatePresignedUrl(pre, e);
         }
     }
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AmazonS3FileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AmazonS3FileStorage.java
index c16d63b2..6615d2a6 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AmazonS3FileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AmazonS3FileStorage.java
@@ -2,7 +2,9 @@
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.io.file.FileNameUtil;
 import cn.hutool.core.util.StrUtil;
+import com.amazonaws.HttpMethod;
 import com.amazonaws.RequestClientOptions;
 import com.amazonaws.event.ProgressEventType;
 import com.amazonaws.services.s3.AmazonS3;
@@ -10,9 +12,8 @@
 import java.io.BufferedInputStream;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
+import java.net.URL;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
@@ -26,6 +27,9 @@
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.get.*;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.upload.*;
 import org.dromara.x.file.storage.core.util.Tools;
 
@@ -274,6 +278,101 @@ public FilePartInfoList listParts(ListPartsPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll();
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        AmazonS3 client = getClient();
+        try {
+            ListObjectsRequest request = new ListObjectsRequest();
+            request.setBucketName(bucketName);
+            request.setMaxKeys(pre.getMaxFiles());
+            request.setMarker(pre.getMarker());
+            request.setDelimiter("/");
+            request.setPrefix(basePath + pre.getPath() + pre.getFilenamePrefix());
+            ObjectListing result = client.listObjects(request);
+            ListFilesResult list = new ListFilesResult();
+
+            list.setDirList(result.getCommonPrefixes().stream()
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(FileNameUtil.getName(item));
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+
+            list.setFileList(result.getObjectSummaries().stream()
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(FileNameUtil.getName(item.getKey()));
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.getSize());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setETag(item.getETag());
+                        info.setLastModified(item.getLastModified());
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(result.getMaxKeys());
+            list.setIsTruncated(result.isTruncated());
+            list.setMarker(result.getMarker());
+            list.setNextMarker(result.getNextMarker());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        AmazonS3 client = getClient();
+        try {
+            S3Object file;
+            try {
+                file = client.getObject(bucketName, fileKey);
+            } catch (Exception e) {
+                return null;
+            }
+            if (file == null) return null;
+            ObjectMetadata metadata = file.getObjectMetadata();
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(FileNameUtil.getName(file.getKey()));
+            info.setUrl(domain + fileKey);
+            info.setSize(metadata.getContentLength());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setETag(metadata.getETag());
+            info.setContentDisposition(metadata.getContentDisposition());
+            info.setContentType(metadata.getContentType());
+            info.setContentMd5(metadata.getContentMD5());
+            info.setLastModified(metadata.getLastModified());
+            if (metadata.getRawMetadata() != null) info.setMetadata(new HashMap<>(metadata.getRawMetadata()));
+            if (metadata.getUserMetadata() != null) info.setUserMetadata(new HashMap<>(metadata.getUserMetadata()));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     /**
      * 获取文件的访问控制列表
      */
@@ -328,24 +427,27 @@ public boolean isSupportPresignedUrl() {
     }
 
     @Override
-    public String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
-        try {
-            return getClient()
-                    .generatePresignedUrl(bucketName, getFileKey(fileInfo), expiration)
-                    .toString();
-        } catch (Exception e) {
-            throw ExceptionFactory.generatePresignedUrl(fileInfo, platform, e);
-        }
-    }
-
-    @Override
-    public String generateThPresignedUrl(FileInfo fileInfo, Date expiration) {
+    public GeneratePresignedUrlResult generatePresignedUrl(GeneratePresignedUrlPretreatment pre) {
         try {
-            String key = getThFileKey(fileInfo);
-            if (key == null) return null;
-            return getClient().generatePresignedUrl(bucketName, key, expiration).toString();
+            String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+            GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, fileKey);
+            request.setExpiration(pre.getExpiration());
+            request.setMethod(Tools.getEnum(HttpMethod.class, pre.getMethod()));
+            Map<String, String> headers = new HashMap<>(pre.getHeaders());
+            headers.putAll(pre.getUserMetadata().entrySet().stream()
+                    .collect(Collectors.toMap(
+                            e -> e.getKey().startsWith("x-amz-meta-") ? e.getKey() : "x-amz-meta-" + e.getKey(),
+                            Map.Entry::getValue)));
+            headers.forEach(request::putCustomRequestHeader);
+            pre.getQueryParams().forEach(request::addRequestParameter);
+            pre.getResponseHeaders().forEach((k, v) -> request.addRequestParameter("response-" + k.toLowerCase(), v));
+            URL url = getClient().generatePresignedUrl(request);
+            GeneratePresignedUrlResult result = new GeneratePresignedUrlResult(platform, basePath, pre);
+            result.setUrl(url.toString());
+            result.setHeaders(request.getCustomRequestHeaders());
+            return result;
         } catch (Exception e) {
-            throw ExceptionFactory.generateThPresignedUrl(fileInfo, platform, e);
+            throw ExceptionFactory.generatePresignedUrl(pre, e);
         }
     }
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AzureBlobStorageFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AzureBlobStorageFileStorage.java
index d68340f1..33137ae7 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AzureBlobStorageFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/AzureBlobStorageFileStorage.java
@@ -4,30 +4,46 @@
 import cn.hutool.core.bean.copier.CopyOptions;
 import cn.hutool.core.codec.Base64;
 import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.io.file.FileNameUtil;
+import cn.hutool.core.map.CaseInsensitiveMap;
+import cn.hutool.core.net.url.UrlQuery;
 import cn.hutool.core.text.NamingCase;
 import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.util.IdUtil;
+import cn.hutool.core.util.ReflectUtil;
 import cn.hutool.core.util.StrUtil;
+import com.azure.core.http.rest.ResponseBase;
 import com.azure.core.util.Context;
 import com.azure.core.util.polling.PollResponse;
 import com.azure.core.util.polling.SyncPoller;
 import com.azure.storage.blob.BlobClient;
+import com.azure.storage.blob.BlobContainerAsyncClient;
+import com.azure.storage.blob.BlobContainerClient;
+import com.azure.storage.blob.implementation.models.BlobItemPropertiesInternal;
+import com.azure.storage.blob.implementation.models.ContainersListBlobHierarchySegmentHeaders;
+import com.azure.storage.blob.implementation.models.ListBlobsHierarchySegmentResponse;
 import com.azure.storage.blob.models.*;
 import com.azure.storage.blob.options.BlobParallelUploadOptions;
 import com.azure.storage.blob.options.BlockBlobCommitBlockListOptions;
 import com.azure.storage.blob.sas.BlobSasPermission;
 import com.azure.storage.blob.sas.BlobServiceSasSignatureValues;
 import com.azure.storage.blob.specialized.BlockBlobClient;
+import com.azure.storage.common.sas.SasIpRange;
+import com.azure.storage.common.sas.SasProtocol;
 import com.azure.storage.file.datalake.*;
 import com.azure.storage.file.datalake.models.PathAccessControlEntry;
 import com.azure.storage.file.datalake.models.PathPermissions;
 import com.azure.storage.file.datalake.models.RolePermissions;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
+import java.lang.reflect.Method;
+import java.nio.charset.StandardCharsets;
 import java.time.Duration;
 import java.time.OffsetDateTime;
 import java.time.ZoneOffset;
 import java.util.*;
+import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import lombok.Data;
@@ -45,9 +61,14 @@
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.exception.FileStorageRuntimeException;
 import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.get.*;
 import org.dromara.x.file.storage.core.platform.AzureBlobStorageFileStorageClientFactory.AzureBlobStorageClient;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.upload.*;
+import org.dromara.x.file.storage.core.util.KebabCaseInsensitiveMap;
 import org.dromara.x.file.storage.core.util.Tools;
+import reactor.core.publisher.Mono;
 
 /**
  * Azure Blob Storage
@@ -104,6 +125,12 @@ public class AzureBlobStorageFileStorage implements FileStorage {
      */
     private Integer maxConcurrency;
 
+    /**
+     * 预签名 URL 时，传入的 HTTP method 与 Azure Blob Storage 中的 SAS 权限映射表
+     * {@link com.azure.storage.blob.sas.BlobSasPermission}
+     */
+    private CaseInsensitiveMap<String, String> methodToPermissionMap;
+
     private FileStorageClientFactory<AzureBlobStorageClient> clientFactory;
 
     public AzureBlobStorageFileStorage(
@@ -116,6 +143,7 @@ public AzureBlobStorageFileStorage(
         multipartThreshold = config.getMultipartThreshold();
         multipartPartSize = config.getMultipartPartSize();
         maxConcurrency = config.getMaxConcurrency();
+        methodToPermissionMap = new CaseInsensitiveMap<>(config.getMethodToPermissionMap());
         this.clientFactory = clientFactory;
     }
 
@@ -123,12 +151,13 @@ public AzureBlobStorageClient getClient() {
         return clientFactory.getClient();
     }
 
+    public BlobContainerClient getBlobClient() {
+        return getClient().getBlobServiceClient().getBlobContainerClient(containerName);
+    }
+
     public BlobClient getBlobClient(String fileKey) {
         if (StrUtil.isBlank(fileKey)) return null;
-        return getClient()
-                .getBlobServiceClient()
-                .getBlobContainerClient(containerName)
-                .getBlobClient(fileKey);
+        return getBlobClient().getBlobClient(fileKey);
     }
 
     public DataLakeFileClient getDataLakeFileClient(String fileKey) {
@@ -206,9 +235,17 @@ public MultipartUploadSupportInfo isSupportMultipartUpload() {
     public void initiateMultipartUpload(FileInfo fileInfo, InitiateMultipartUploadPretreatment pre) {
         fileInfo.setBasePath(basePath);
         String newFileKey = getFileKey(fileInfo);
-        fileInfo.setBasePath(basePath);
         fileInfo.setUrl(getUrl(newFileKey));
-        fileInfo.setUploadId(IdUtil.objectId());
+        BlockBlobClient blobClient = getBlobClient(getFileKey(fileInfo)).getBlockBlobClient();
+        try {
+            String uploadId = IdUtil.objectId();
+            fileInfo.setUploadId(uploadId);
+            String blockIdBase64 = Base64.encode(String.format("%06d", 0));
+            byte[] bytes = fileInfo.getUploadId().getBytes(StandardCharsets.UTF_8);
+            blobClient.stageBlock(blockIdBase64, new ByteArrayInputStream(bytes), bytes.length);
+        } catch (Exception e) {
+            throw ExceptionFactory.initiateMultipartUpload(fileInfo, platform, e);
+        }
     }
 
     /**
@@ -280,22 +317,160 @@ public FilePartInfoList listParts(ListPartsPretreatment pre) {
         BlockBlobClient client = getBlobClient(getFileKey(fileInfo)).getBlockBlobClient();
         try {
             BlockList blockList = client.listBlocks(BlockListType.UNCOMMITTED);
-            FilePartInfoList list = new FilePartInfoList();
-            list.setFileInfo(fileInfo);
-            list.setList(blockList.getUncommittedBlocks().stream()
+
+            List<FilePartInfo> partList = blockList.getUncommittedBlocks().stream()
                     .map(p -> {
                         FilePartInfo filePartInfo = new FilePartInfo(fileInfo);
                         filePartInfo.setPartSize(p.getSizeLong());
                         filePartInfo.setPartNumber(Integer.parseInt(Base64.decodeStr(p.getName())));
                         return filePartInfo;
                     })
-                    .collect(Collectors.toList()));
+                    .filter(p -> p.getPartNumber() > pre.getPartNumberMarker())
+                    .filter(v -> v.getPartNumber() > 0)
+                    .sorted(Comparator.comparingInt(FilePartInfo::getPartNumber))
+                    .collect(Collectors.toList());
+
+            FilePartInfoList list = new FilePartInfoList();
+            list.setFileInfo(fileInfo);
+            list.setMaxParts(pre.getMaxParts());
+            list.setPartNumberMarker(pre.getPartNumberMarker());
+
+            if (partList.size() > pre.getMaxParts()) {
+                list.setIsTruncated(true);
+                partList = partList.subList(0, pre.getMaxParts());
+                list.setNextPartNumberMarker(partList.get(partList.size() - 1).getPartNumber());
+            } else {
+                list.setIsTruncated(false);
+            }
+            list.setList(partList);
+
             return list;
         } catch (Exception e) {
             throw ExceptionFactory.listParts(fileInfo, platform, e);
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll().setSupportMaxFiles(5000);
+    }
+
+    /**
+     * 通过反射调用内部的列举文件方法
+     */
+    public ListBlobsHierarchySegmentResponse listFiles(
+            BlobContainerClient client, String marker, String delimiter, ListBlobsOptions options, Duration timeout)
+            throws ExecutionException, InterruptedException {
+        BlobContainerAsyncClient asyncClient = (BlobContainerAsyncClient) ReflectUtil.getFieldValue(client, "client");
+        Method method = ReflectUtil.getMethodByName(asyncClient.getClass(), "listBlobsHierarchySegment");
+        Mono<ResponseBase<ContainersListBlobHierarchySegmentHeaders, ListBlobsHierarchySegmentResponse>> result =
+                ReflectUtil.invoke(asyncClient, method, marker, delimiter, options, timeout);
+        return Objects.requireNonNull(result.block()).getValue();
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        BlobContainerClient client = getBlobClient();
+        try {
+
+            ListBlobsOptions options = new ListBlobsOptions()
+                    .setPrefix(basePath + pre.getPath() + pre.getFilenamePrefix())
+                    .setMaxResultsPerPage(pre.getMaxFiles())
+                    .setDetails(new BlobListDetails().setRetrieveMetadata(true));
+
+            ListBlobsHierarchySegmentResponse result = listFiles(client, pre.getMarker(), "/", options, null);
+
+            ListFilesResult list = new ListFilesResult();
+            list.setDirList(result.getSegment().getBlobPrefixes().stream()
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(FileNameUtil.getName(item.getName().getContent()));
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+            list.setFileList(result.getSegment().getBlobItems().stream()
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(FileNameUtil.getName(item.getName().getContent()));
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        BlobItemPropertiesInternal properties = item.getProperties();
+                        info.setSize(properties.getContentLength());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setContentDisposition(properties.getContentDisposition());
+                        info.setETag(properties.getETag());
+                        info.setContentType(properties.getContentType());
+                        info.setContentMd5(Base64.encode(properties.getContentMd5()));
+                        info.setLastModified(DateUtil.date(properties.getLastModified()));
+                        try {
+                            info.setMetadata(BeanUtil.beanToMap(properties, false, true));
+                        } catch (Exception ignored) {
+                        }
+                        if (item.getMetadata() != null) info.setUserMetadata(new HashMap<>(item.getMetadata()));
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(result.getMaxResults());
+            list.setIsTruncated(StrUtil.isNotBlank(result.getNextMarker()));
+            list.setMarker(result.getMarker());
+            list.setNextMarker(result.getNextMarker());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        try {
+            BlobClient client = getBlobClient(fileKey);
+            BlobProperties file;
+            try {
+                file = client.getProperties();
+            } catch (Exception e) {
+                return null;
+            }
+            if (file == null) return null;
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(FileNameUtil.getName(client.getBlobName()));
+            info.setUrl(domain + fileKey);
+            info.setSize(file.getBlobSize());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setETag(file.getETag());
+            info.setContentDisposition(file.getContentDisposition());
+            info.setContentType(file.getContentType());
+            info.setContentMd5(Base64.encode(file.getContentMd5()));
+            info.setLastModified(DateUtil.date(file.getLastModified()));
+            try {
+                info.setMetadata(BeanUtil.beanToMap(
+                        ReflectUtil.getFieldValue(ReflectUtil.getFieldValue(file, "internalProperties"), "headers"),
+                        false,
+                        true));
+            } catch (Exception ignored) {
+            }
+            if (file.getMetadata() != null) info.setUserMetadata(new HashMap<>(file.getMetadata()));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     @Override
     public boolean isSupportAcl() {
         return true;
@@ -450,32 +625,76 @@ public boolean isSupportPresignedUrl() {
         return true;
     }
 
-    /**
-     * 对文件生成可以签名访问的 URL，无法生成则返回 null
-     * 如果存在跨域问题，需要去控制台 （资源共享(CORS)界面）授权允许的跨域规则
-     * 生成url的每个参数的含义{@link com.azure.storage.blob.implementation.util.BlobSasImplUtil#encode(UserDelegationKey, String)}
-     * @param expiration 到期时间
-     */
-    @Override
-    public String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
-        try {
-            BlobClient blobClient = getBlobClient(getFileKey(fileInfo));
-            return blobClient.getBlobUrl() + "?" + blobClient.generateSas(getBlobServiceSasSignatureValues(expiration));
-        } catch (Exception e) {
-            throw ExceptionFactory.generatePresignedUrl(fileInfo, platform, e);
+    public BlobSasPermission getBlobSasPermission(Object object) {
+        if (object instanceof BlobSasPermission) {
+            return (BlobSasPermission) object;
+        } else if (object instanceof String) {
+            String permission = methodToPermissionMap.get(object);
+            if (permission == null) permission = object.toString();
+            return BlobSasPermission.parse(permission);
         }
+        throw new IllegalArgumentException("无法识别的权限");
     }
 
     @Override
-    public String generateThPresignedUrl(FileInfo fileInfo, Date expiration) {
+    public GeneratePresignedUrlResult generatePresignedUrl(GeneratePresignedUrlPretreatment pre) {
         try {
-            String key = getThFileKey(fileInfo);
-            if (key == null) return null;
-            BlobClient thBlobClient = getBlobClient(getThFileKey(fileInfo));
-            return thBlobClient.getBlobUrl() + "?"
-                    + thBlobClient.generateSas(getBlobServiceSasSignatureValues(expiration));
+            String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+            Map<String, String> headers = new HashMap<>(pre.getHeaders());
+            headers.putAll(pre.getUserMetadata().entrySet().stream()
+                    .collect(Collectors.toMap(
+                            e -> e.getKey().startsWith("x-ms-meta-") ? e.getKey() : "x-ms-meta-" + e.getKey(),
+                            Map.Entry::getValue)));
+
+            BlobClient blobClient = getBlobClient(fileKey);
+            BlobSasPermission permission = getBlobSasPermission(pre.getMethod());
+            OffsetDateTime expiration =
+                    pre.getExpiration().toInstant().atZone(ZoneOffset.UTC).toOffsetDateTime();
+
+            // 生成签名
+            BlobServiceSasSignatureValues values = new BlobServiceSasSignatureValues(expiration, permission);
+            KebabCaseInsensitiveMap<String, String> responseHeaders =
+                    new KebabCaseInsensitiveMap<>(pre.getResponseHeaders());
+            values.setCacheControl(responseHeaders.get(Constant.Metadata.CACHE_CONTROL));
+            values.setContentDisposition(responseHeaders.get(Constant.Metadata.CONTENT_DISPOSITION));
+            values.setContentEncoding(responseHeaders.get(Constant.Metadata.CONTENT_ENCODING));
+            values.setContentLanguage(responseHeaders.get(Constant.Metadata.CONTENT_LANGUAGE));
+            values.setContentType(responseHeaders.get(Constant.Metadata.CONTENT_TYPE));
+            if (pre.getStartTime() != null)
+                values.setStartTime(
+                        pre.getStartTime().toInstant().atZone(ZoneOffset.UTC).toOffsetDateTime());
+
+            Map<String, String> queryParams = pre.getQueryParams();
+            if (CollUtil.isNotEmpty(queryParams)) {
+                if (queryParams.get("protocol") != null)
+                    values.setProtocol(SasProtocol.parse(queryParams.get("protocol")));
+                if (queryParams.get("sasIpRange") != null)
+                    values.setSasIpRange(SasIpRange.parse(queryParams.get("sasIpRange")));
+                try {
+                    values.setSnapshotId(queryParams.get("snapshotId"));
+                } catch (Exception ignored) {
+                }
+                values.setIdentifier(queryParams.get("identifier"));
+                values.setPreauthorizedAgentObjectId(queryParams.get("preauthorizedAgentObjectId"));
+                values.setCorrelationId(queryParams.get("correlationId"));
+            }
+
+            StringBuilder url = new StringBuilder();
+            url.append(blobClient.getBlobUrl()).append("?");
+            if (CollUtil.isNotEmpty(queryParams)) {
+                url.append(UrlQuery.of(queryParams).build(StandardCharsets.UTF_8))
+                        .append("&");
+            }
+            url.append(blobClient.generateSas(values));
+
+            GeneratePresignedUrlResult result = new GeneratePresignedUrlResult(platform, basePath, pre);
+            result.setUrl(url.toString());
+            Map<String, String> resHeaders = new HashMap<>(headers);
+            resHeaders.put("x-ms-blob-type", "BlockBlob");
+            result.setHeaders(resHeaders);
+            return result;
         } catch (Exception e) {
-            throw ExceptionFactory.generateThPresignedUrl(fileInfo, platform, e);
+            throw ExceptionFactory.generatePresignedUrl(pre, e);
         }
     }
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/BaiduBosFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/BaiduBosFileStorage.java
index 8383eef5..312bdcb7 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/BaiduBosFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/BaiduBosFileStorage.java
@@ -4,17 +4,18 @@
 import cn.hutool.core.bean.copier.CopyOptions;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.io.file.FileNameUtil;
 import cn.hutool.core.text.NamingCase;
 import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.util.StrUtil;
 import com.baidubce.BceServiceException;
+import com.baidubce.http.HttpMethodName;
 import com.baidubce.services.bos.BosClient;
 import com.baidubce.services.bos.model.*;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
+import java.net.URL;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
@@ -30,6 +31,9 @@
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.get.*;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.upload.*;
 import org.dromara.x.file.storage.core.util.Tools;
 
@@ -271,6 +275,101 @@ public FilePartInfoList listParts(ListPartsPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll();
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        BosClient client = getClient();
+        try {
+            ListObjectsRequest request = new ListObjectsRequest(bucketName);
+            request.setMaxKeys(pre.getMaxFiles());
+            request.setMarker(pre.getMarker());
+            request.setDelimiter("/");
+            request.setPrefix(basePath + pre.getPath() + pre.getFilenamePrefix());
+            ListObjectsResponse result = client.listObjects(request);
+            ListFilesResult list = new ListFilesResult();
+
+            list.setDirList(result.getCommonPrefixes().stream()
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(FileNameUtil.getName(item));
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+
+            list.setFileList(result.getContents().stream()
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(FileNameUtil.getName(item.getKey()));
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.getSize());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setETag(item.getETag());
+                        info.setLastModified(item.getLastModified());
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(result.getMaxKeys());
+            list.setIsTruncated(result.isTruncated());
+            list.setMarker(result.getMarker());
+            list.setNextMarker(result.getNextMarker());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        BosClient client = getClient();
+        try {
+            BosObject file;
+            try {
+                file = client.getObject(bucketName, fileKey);
+            } catch (Exception e) {
+                return null;
+            }
+            if (file == null) return null;
+            ObjectMetadata metadata = file.getObjectMetadata();
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(FileNameUtil.getName(file.getKey()));
+            info.setUrl(domain + fileKey);
+            info.setSize(metadata.getContentLength());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setETag(metadata.getETag());
+            info.setContentDisposition(metadata.getContentDisposition());
+            info.setContentType(metadata.getContentType());
+            info.setContentMd5(metadata.getContentMd5());
+            info.setLastModified(metadata.getLastModified());
+            info.setMetadata(BeanUtil.beanToMap(metadata, false, true));
+            info.getMetadata().remove("userMetadata");
+            if (metadata.getUserMetadata() != null) info.setUserMetadata(new HashMap<>(metadata.getUserMetadata()));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     public CannedAccessControlList getAcl(Object acl) {
         if (acl instanceof CannedAccessControlList) {
             return (CannedAccessControlList) acl;
@@ -332,26 +431,29 @@ public boolean isSupportPresignedUrl() {
     }
 
     @Override
-    public String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
-        try {
-            int expires = (int) ((expiration.getTime() - System.currentTimeMillis()) / 1000);
-            return getClient()
-                    .generatePresignedUrl(bucketName, getFileKey(fileInfo), expires)
-                    .toString();
-        } catch (Exception e) {
-            throw ExceptionFactory.generatePresignedUrl(fileInfo, platform, e);
-        }
-    }
-
-    @Override
-    public String generateThPresignedUrl(FileInfo fileInfo, Date expiration) {
+    public GeneratePresignedUrlResult generatePresignedUrl(GeneratePresignedUrlPretreatment pre) {
         try {
-            String key = getThFileKey(fileInfo);
-            if (key == null) return null;
-            int expires = (int) ((expiration.getTime() - System.currentTimeMillis()) / 1000);
-            return getClient().generatePresignedUrl(bucketName, key, expires).toString();
+            String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+            GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, fileKey);
+            request.setExpiration((int) ((pre.getExpiration().getTime() - System.currentTimeMillis()) / 1000));
+            request.setMethod(Tools.getEnum(HttpMethodName.class, pre.getMethod()));
+            Map<String, String> headers = new HashMap<>(pre.getHeaders());
+            headers.putAll(pre.getUserMetadata().entrySet().stream()
+                    .collect(Collectors.toMap(
+                            e -> e.getKey().startsWith("x-bce-meta-") ? e.getKey() : "x-bce-meta-" + e.getKey(),
+                            Map.Entry::getValue)));
+            headers.forEach(request::addRequestHeaders);
+            pre.getQueryParams().forEach(request::addRequestParameter);
+            pre.getResponseHeaders()
+                    .forEach((k, v) ->
+                            request.addRequestParameter(NamingCase.toCamelCase("response-" + k.toLowerCase(), '-'), v));
+            URL url = getClient().generatePresignedUrl(request);
+            GeneratePresignedUrlResult result = new GeneratePresignedUrlResult(platform, basePath, pre);
+            result.setUrl(url.toString());
+            result.setHeaders(headers);
+            return result;
         } catch (Exception e) {
-            throw ExceptionFactory.generateThPresignedUrl(fileInfo, platform, e);
+            throw ExceptionFactory.generatePresignedUrl(pre, e);
         }
     }
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FastDfsFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FastDfsFileStorage.java
index a9990391..f84bae83 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FastDfsFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FastDfsFileStorage.java
@@ -2,19 +2,21 @@
 
 import cn.hutool.core.io.IoUtil;
 import cn.hutool.core.io.file.FileNameUtil;
+import cn.hutool.core.map.MapProxy;
 import cn.hutool.core.thread.ThreadUtil;
 import cn.hutool.core.util.StrUtil;
 import java.io.*;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 import java.util.function.Function;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
-import lombok.Setter;
+import java.util.stream.Collectors;
+import lombok.*;
+import lombok.experimental.Accessors;
 import lombok.extern.slf4j.Slf4j;
 import org.csource.common.MyException;
 import org.csource.common.NameValuePair;
@@ -25,9 +27,13 @@
 import org.dromara.x.file.storage.core.InputStreamPlus;
 import org.dromara.x.file.storage.core.ProgressListener;
 import org.dromara.x.file.storage.core.UploadPretreatment;
+import org.dromara.x.file.storage.core.constant.Constant;
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.get.GetFilePretreatment;
+import org.dromara.x.file.storage.core.get.RemoteFileInfo;
+import org.dromara.x.file.storage.core.util.KebabCaseInsensitiveMap;
 import org.dromara.x.file.storage.core.util.Tools;
 
 /**
@@ -180,6 +186,55 @@ public boolean save(FileInfo fileInfo, UploadPretreatment pre) {
         }
     }
 
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        StorageClient client = getClient();
+        try {
+            String[] arr = getGroupAndFilename(new FileInfo()
+                    .setPath(pre.getPath())
+                    .setFilename(pre.getFilename())
+                    .setUrl(pre.getUrl()));
+            org.csource.fastdfs.FileInfo file;
+            try {
+                file = client.get_file_info(arr[0], arr[1]);
+                if (file == null) return null;
+            } catch (Exception e) {
+                return null;
+            }
+            NameValuePair[] metadata = null;
+            try {
+                metadata = client.get_metadata(arr[0], arr[1]);
+            } catch (Exception ignored) {
+            }
+            if (metadata == null) metadata = new NameValuePair[0];
+
+            KebabCaseInsensitiveMap<String, String> headers = new KebabCaseInsensitiveMap<>(
+                    Arrays.stream(metadata).collect(Collectors.toMap(NameValuePair::getName, NameValuePair::getValue)));
+            MapProxy headersProxy = MapProxy.create(headers);
+
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(config.getBasePath());
+            setGroupAndFilename(info, arr);
+            info.setSize(file.getFileSize());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setContentDisposition(headersProxy.getStr(Constant.Metadata.CONTENT_DISPOSITION));
+            info.setContentType(headersProxy.getStr(Constant.Metadata.CONTENT_TYPE));
+            info.setContentMd5(headersProxy.getStr(Constant.Metadata.CONTENT_MD5));
+            info.setLastModified(file.getCreateTimestamp());
+            info.setMetadata(headers.entrySet().stream()
+                    .filter(e -> !e.getKey().startsWith("x-amz-meta-"))
+                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
+            info.setUserMetadata(headers.entrySet().stream()
+                    .filter(e -> e.getKey().startsWith("x-amz-meta-"))
+                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
+            info.setOriginal(new FastDfsFileInfo(file, metadata));
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, config.getBasePath(), e);
+        }
+    }
+
     /**
      * 获取对象的元数据
      * 注意，这里不支持 UserMetadata 用户元数据，所以使用 Amazon S3 的规则进行模拟，所有用户元数据都自动增加 "x-amz-meta-" 前缀
@@ -358,6 +413,16 @@ public void setThGroupAndFilename(FileInfo fileInfo, String[] arr) {
         }
     }
 
+    /**
+     * 将 FastDFS 返回的 group 和 filename 保存到 RemoteFileInfo 文件信息中
+     */
+    public void setGroupAndFilename(RemoteFileInfo info, String[] arr) {
+        info.setUrl(config.getDomain() + arr[0] + "/" + arr[1]);
+        Path path = Paths.get(arr[0], arr[1]);
+        info.setPath(path.getParent().toString().replace("\\", "/") + "/");
+        info.setFilename(path.getFileName().toString());
+    }
+
     /**
      * 获取文件对应的 FastDFS 支持的 group 和 filename，失败返回 null
      * @param fileInfo 文件信息
@@ -411,4 +476,22 @@ public String[] getGroupAndFilenameByUrl(String url) {
             return null;
         }
     }
+
+    /**
+     * FastDFS 的文件信息
+     */
+    @Data
+    @Accessors(chain = true)
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class FastDfsFileInfo {
+        /**
+         * 文件信息
+         */
+        private org.csource.fastdfs.FileInfo fileInfo;
+        /**
+         * 元数据
+         */
+        private NameValuePair[] metadata;
+    }
 }
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FileStorage.java
index 7278f40f..406eafef 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FileStorage.java
@@ -1,13 +1,23 @@
 package org.dromara.x.file.storage.core.platform;
 
+import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.StrUtil;
 import java.io.InputStream;
-import java.util.Date;
+import java.util.Comparator;
+import java.util.List;
 import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.experimental.Accessors;
 import org.dromara.x.file.storage.core.FileInfo;
 import org.dromara.x.file.storage.core.UploadPretreatment;
 import org.dromara.x.file.storage.core.copy.CopyPretreatment;
+import org.dromara.x.file.storage.core.get.*;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.upload.*;
 import org.dromara.x.file.storage.core.util.Tools;
 
@@ -68,27 +78,70 @@ default FilePartInfoList listParts(ListPartsPretreatment pre) {
     }
 
     /**
-     * 是否支持对文件生成可以签名访问的 URL
+     * 是否支持列举文件
      */
-    default boolean isSupportPresignedUrl() {
-        return false;
+    default ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.notSupport();
     }
 
     /**
-     * 对文件生成可以签名访问的 URL，无法生成则返回 null
-     *
-     * @param expiration 到期时间
+     * 列举文件-匹配文件
+     */
+    default <T> ListFilesMatchResult<T> listFilesMatch(
+            List<T> list, Function<T, String> nameGetter, ListFilesPretreatment pre, boolean sort) {
+        // 匹配文件名前缀
+        if (CollUtil.isNotEmpty(list) && StrUtil.isNotEmpty(pre.getFilenamePrefix())) {
+            list = list.stream()
+                    .filter(p -> nameGetter.apply(p).startsWith(pre.getFilenamePrefix()))
+                    .collect(Collectors.toList());
+        }
+        // 排序
+        if (CollUtil.isNotEmpty(list) && sort) {
+            list = list.stream().sorted(Comparator.comparing(nameGetter)).collect(Collectors.toList());
+        }
+        // 分页-确定开始位置
+        if (CollUtil.isNotEmpty(list) && StrUtil.isNotEmpty(pre.getMarker())) {
+            int index = CollUtil.indexOf(list, p -> nameGetter.apply(p).equals(pre.getMarker()));
+            if (index >= 0) list = list.subList(index + 1, list.size());
+        }
+        // 分页-确定结束位置
+        boolean isTruncated = false;
+        String nextMarker = null;
+        if (CollUtil.isNotEmpty(list) && pre.getMaxFiles() != null && list.size() > pre.getMaxFiles()) {
+            list = list.subList(0, pre.getMaxFiles());
+            isTruncated = true;
+            nextMarker = nameGetter.apply(list.get(list.size() - 1));
+        }
+        return new ListFilesMatchResult<>(list, isTruncated, nextMarker);
+    }
+
+    /**
+     * 列举文件
+     */
+    default ListFilesResult listFiles(ListFilesPretreatment pre) {
+        return null;
+    }
+
+    /**
+     * 获取文件
      */
-    default String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
+    default RemoteFileInfo getFile(GetFilePretreatment pre) {
         return null;
     }
 
     /**
-     * 对缩略图文件生成可以签名访问的 URL，无法生成则返回 null
+     * 是否支持对文件生成可以签名访问的 URL
+     */
+    default boolean isSupportPresignedUrl() {
+        return false;
+    }
+
+    /**
+     * 生成预签名 URL
      *
-     * @param expiration 到期时间
+     * @param pre 生成预签名 URL 预处理器
      */
-    default String generateThPresignedUrl(FileInfo fileInfo, Date expiration) {
+    default GeneratePresignedUrlResult generatePresignedUrl(GeneratePresignedUrlPretreatment pre) {
         return null;
     }
 
@@ -190,4 +243,25 @@ default String getThFileKey(FileInfo fileInfo) {
                 + Tools.getNotNull(fileInfo.getPath(), StrUtil.EMPTY)
                 + Tools.getNotNull(fileInfo.getThFilename(), StrUtil.EMPTY);
     }
+
+    /**
+     * 列举文件-匹配结果
+     */
+    @Data
+    @Accessors(chain = true)
+    @AllArgsConstructor
+    class ListFilesMatchResult<T> {
+        /**
+         * 列表
+         */
+        private List<T> list;
+        /**
+         * 列表是否被截断，就是当前 uploadId下还有其它分片超出最大分片数量未被列举
+         */
+        private Boolean isTruncated;
+        /**
+         * 下次列举的起始位置
+         */
+        private String nextMarker;
+    }
 }
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FtpFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FtpFileStorage.java
index f94a935c..f72a70c1 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FtpFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/FtpFileStorage.java
@@ -1,11 +1,16 @@
 package org.dromara.x.file.storage.core.platform;
 
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.io.file.FileNameUtil;
 import cn.hutool.core.util.StrUtil;
 import cn.hutool.extra.ftp.Ftp;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
@@ -18,6 +23,7 @@
 import org.dromara.x.file.storage.core.UploadPretreatment;
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
+import org.dromara.x.file.storage.core.get.*;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
 
 /**
@@ -102,6 +108,99 @@ public boolean save(FileInfo fileInfo, UploadPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll().setSupportMaxFiles(Integer.MAX_VALUE);
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        Ftp client = getClient();
+        try {
+            String path = getAbsolutePath(basePath + pre.getPath());
+            List<FTPFile> fileList = Arrays.stream(client.isDir(path) ? client.lsFiles(path) : new FTPFile[0])
+                    .filter(f -> f.isFile() || f.isDirectory())
+                    .filter(f -> !(".".equals(f.getName()) || "..".equals(f.getName())))
+                    .collect(Collectors.toList());
+            ListFilesMatchResult<FTPFile> matchResult = listFilesMatch(fileList, FTPFile::getName, pre, true);
+            ListFilesResult list = new ListFilesResult();
+            list.setDirList(matchResult.getList().stream()
+                    .filter(FTPFile::isDirectory)
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(item.getName());
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+            list.setFileList(matchResult.getList().stream()
+                    .filter(FTPFile::isFile)
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(item.getName());
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.getSize());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setLastModified(DateUtil.date(item.getTimestamp()));
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(pre.getMaxFiles());
+            list.setIsTruncated(matchResult.getIsTruncated());
+            list.setMarker(pre.getMarker());
+            list.setNextMarker(matchResult.getNextMarker());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        } finally {
+            returnClient(client);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        Ftp client = getClient();
+        try {
+            String path = getAbsolutePath(basePath + pre.getPath());
+            FTPFile file;
+            try {
+                client.cd(path);
+                file = client.getClient().listFiles(pre.getFilename())[0];
+            } catch (Exception e) {
+                return null;
+            }
+            if (file == null) return null;
+
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(file.getName());
+            info.setUrl(domain + fileKey);
+            info.setSize(file.getSize());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setLastModified(DateUtil.date(file.getTimestamp()));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        } finally {
+            returnClient(client);
+        }
+    }
+
     @Override
     public boolean delete(FileInfo fileInfo) {
         Ftp client = getClient();
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/GoogleCloudStorageFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/GoogleCloudStorageFileStorage.java
index bea0df5b..968efb38 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/GoogleCloudStorageFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/GoogleCloudStorageFileStorage.java
@@ -3,15 +3,21 @@
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.bean.copier.CopyOptions;
 import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.collection.ListUtil;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.io.file.FileNameUtil;
 import cn.hutool.core.text.NamingCase;
-import cn.hutool.core.util.CharUtil;
-import cn.hutool.core.util.StrUtil;
+import cn.hutool.core.util.*;
+import com.google.api.gax.paging.Page;
 import com.google.cloud.ReadChannel;
 import com.google.cloud.storage.*;
 import com.google.cloud.storage.Storage.CopyRequest;
 import com.google.cloud.storage.Storage.PredefinedAcl;
+import com.google.cloud.storage.Storage.SignUrlOption;
 import java.io.ByteArrayInputStream;
+import java.io.FileNotFoundException;
 import java.io.InputStream;
+import java.net.URL;
 import java.nio.channels.Channels;
 import java.util.*;
 import java.util.concurrent.TimeUnit;
@@ -26,10 +32,16 @@
 import org.dromara.x.file.storage.core.InputStreamPlus;
 import org.dromara.x.file.storage.core.ProgressListener;
 import org.dromara.x.file.storage.core.UploadPretreatment;
+import org.dromara.x.file.storage.core.constant.Constant;
 import org.dromara.x.file.storage.core.copy.CopyPretreatment;
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.exception.FileStorageRuntimeException;
+import org.dromara.x.file.storage.core.get.*;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
+import org.dromara.x.file.storage.core.upload.*;
+import org.dromara.x.file.storage.core.util.Tools;
 
 /**
  * GoogleCloud Storage 存储
@@ -42,9 +54,7 @@
 @Setter
 @NoArgsConstructor
 public class GoogleCloudStorageFileStorage implements FileStorage {
-    private String projectId;
     private String bucketName;
-    private String credentialsPath;
     private String basePath;
     private String platform;
     private String domain;
@@ -108,6 +118,326 @@ public boolean save(FileInfo fileInfo, UploadPretreatment pre) {
         }
     }
 
+    @Override
+    public MultipartUploadSupportInfo isSupportMultipartUpload() {
+        return MultipartUploadSupportInfo.supportAll().setListPartsSupportMaxParts(10000);
+    }
+
+    @Override
+    public void initiateMultipartUpload(FileInfo fileInfo, InitiateMultipartUploadPretreatment pre) {
+        fileInfo.setBasePath(basePath);
+        String newFileKey = getFileKey(fileInfo);
+        fileInfo.setUrl(domain + newFileKey);
+        Storage client = getClient();
+        try {
+            String uploadId = "multi_" + IdUtil.objectId();
+            String path = Tools.getParent(newFileKey) + "/" + uploadId + "/";
+            ByteArrayInputStream in = new ByteArrayInputStream(new byte[0]);
+            client.createFrom(BlobInfo.newBuilder(bucketName, path + "index").build(), in);
+            fileInfo.setUploadId(uploadId);
+        } catch (Exception e) {
+            throw ExceptionFactory.initiateMultipartUpload(fileInfo, platform, e);
+        }
+    }
+
+    @Override
+    public FilePartInfo uploadPart(UploadPartPretreatment pre) {
+        FileInfo fileInfo = pre.getFileInfo();
+        String newFileKey = getFileKey(fileInfo);
+        Storage client = getClient();
+        try (InputStreamPlus in = pre.getInputStreamPlus()) {
+            String part = Tools.getParent(newFileKey) + "/" + fileInfo.getUploadId() + "/"
+                    + StrUtil.padPre(String.valueOf(pre.getPartNumber()), 10, "0");
+            Blob blob = client.createFrom(BlobInfo.newBuilder(bucketName, part).build(), in);
+            FilePartInfo filePartInfo = new FilePartInfo(fileInfo);
+            filePartInfo.setETag(blob.getEtag());
+            filePartInfo.setPartNumber(pre.getPartNumber());
+            filePartInfo.setPartSize(in.getProgressSize());
+            filePartInfo.setCreateTime(new Date());
+            return filePartInfo;
+        } catch (Exception e) {
+            throw ExceptionFactory.uploadPart(fileInfo, platform, e);
+        }
+    }
+
+    @Override
+    public void completeMultipartUpload(CompleteMultipartUploadPretreatment pre) {
+        FileInfo fileInfo = pre.getFileInfo();
+        String newFileKey = getFileKey(fileInfo);
+        Storage client = getClient();
+        try {
+            ProgressListener.quickStart(pre.getProgressListener(), fileInfo.getSize());
+            client.delete(BlobId.of(bucketName, newFileKey));
+            String path = Tools.getParent(newFileKey) + "/" + fileInfo.getUploadId() + "/";
+            LinkedList<String> sources = pre.getPartInfoList().stream()
+                    .map(part -> path + StrUtil.padPre(String.valueOf(part.getPartNumber()), 10, "0"))
+                    .collect(Collectors.toCollection(LinkedList::new));
+            ArrayList<String> subSources = new ArrayList<>();
+            for (int i = 0; i < sources.size(); i++) {
+                subSources.add(sources.get(i));
+                // 每次最多合并 32 个文件，超过部分需要多次合并
+                if (subSources.size() == 32 || i + 1 == sources.size()) {
+                    Storage.ComposeRequest request;
+                    ArrayList<Storage.BlobTargetOption> optionList = null;
+                    // 最后一次合并需要传入全部相关数据
+                    if (i + 1 == sources.size()) {
+                        optionList = new ArrayList<>();
+                        BlobInfo.Builder blobInfoBuilder = BlobInfo.newBuilder(bucketName, newFileKey);
+                        setMetadataOfBlobTargetOption(blobInfoBuilder, fileInfo, optionList);
+                        request = Storage.ComposeRequest.newBuilder()
+                                .setTarget(blobInfoBuilder.build())
+                                .setTargetOptions(optionList)
+                                .addSource(subSources)
+                                .build();
+                    } else {
+                        request = Storage.ComposeRequest.of(bucketName, subSources, newFileKey);
+                    }
+                    Blob blob = client.compose(request);
+                    if (CollUtil.isNotEmpty(optionList)) {
+                        blob.update(optionList.toArray(optionList.toArray(new Storage.BlobTargetOption[0])));
+                    }
+                    ProgressListener.quickProgress(pre.getProgressListener(), blob.getSize(), fileInfo.getSize());
+                    subSources.clear();
+                    subSources.add(newFileKey);
+                }
+            }
+
+            List<BlobId> blobIdList =
+                    ListUtil.toList(client.list(bucketName, Storage.BlobListOption.prefix(path))
+                                    .iterateAll())
+                            .stream()
+                            .map(BlobInfo::getBlobId)
+                            .collect(Collectors.toList());
+            if (!blobIdList.isEmpty()) client.delete(blobIdList);
+            ProgressListener.quickFinish(pre.getProgressListener());
+        } catch (Exception e) {
+            try {
+                client.delete(BlobId.of(bucketName, newFileKey));
+            } catch (Exception ignored) {
+            }
+            throw ExceptionFactory.completeMultipartUpload(fileInfo, platform, e);
+        }
+    }
+
+    @Override
+    public void abortMultipartUpload(AbortMultipartUploadPretreatment pre) {
+        FileInfo fileInfo = pre.getFileInfo();
+        String newFileKey = getFileKey(fileInfo);
+        Storage client = getClient();
+        try {
+            String path = Tools.getParent(newFileKey) + "/" + fileInfo.getUploadId() + "/";
+            List<BlobId> blobIdList =
+                    ListUtil.toList(client.list(bucketName, Storage.BlobListOption.prefix(path))
+                                    .iterateAll())
+                            .stream()
+                            .map(BlobInfo::getBlobId)
+                            .collect(Collectors.toList());
+            if (!blobIdList.isEmpty()) client.delete(blobIdList);
+        } catch (Exception e) {
+            throw ExceptionFactory.abortMultipartUpload(fileInfo, platform, e);
+        }
+    }
+
+    @Override
+    public FilePartInfoList listParts(ListPartsPretreatment pre) {
+        FileInfo fileInfo = pre.getFileInfo();
+        String newFileKey = getFileKey(fileInfo);
+        Storage client = getClient();
+        try {
+            String path = Tools.getParent(newFileKey) + "/" + fileInfo.getUploadId() + "/";
+            if (client.get(BlobId.of(bucketName, path + "index")) == null) {
+                throw new FileNotFoundException(path + "index");
+            }
+
+            ArrayList<Storage.BlobListOption> options = new ArrayList<>();
+            //            options.add(Storage.BlobListOption.pageSize(pre.getMaxParts()));
+            //            if (pre.getPartNumberMarker() != null && pre.getPartNumberMarker() > 0) {
+            //                options.add(Storage.BlobListOption.pageToken(String.valueOf(pre.getPartNumberMarker())));
+            //            }
+            options.add(Storage.BlobListOption.delimiter("/"));
+            options.add(Storage.BlobListOption.prefix(path));
+            Page<Blob> result = client.list(bucketName, options.toArray(new Storage.BlobListOption[] {}));
+
+            FilePartInfoList list = new FilePartInfoList();
+            list.setFileInfo(fileInfo);
+
+            ArrayList<FilePartInfo> partList = new ArrayList<>();
+            int i = 1;
+            for (Blob p : result.iterateAll()) {
+                String filename = FileNameUtil.getName(p.getName());
+                int partNumber;
+                try {
+                    partNumber = Integer.parseInt(filename);
+                } catch (Exception e) {
+                    continue;
+                }
+                if (pre.getPartNumberMarker() != null && pre.getPartNumberMarker() > 0) {
+                    if (partNumber <= pre.getPartNumberMarker()) continue;
+                }
+                FilePartInfo filePartInfo = new FilePartInfo(fileInfo);
+                filePartInfo.setETag(p.getEtag());
+                filePartInfo.setPartNumber(partNumber);
+                filePartInfo.setPartSize(p.getSize());
+                filePartInfo.setLastModified(DateUtil.date(p.getUpdateTimeOffsetDateTime()));
+                partList.add(filePartInfo);
+                // 这里多获取一个，用于判断是否还有更多分片待读取
+                if (i == pre.getMaxParts() + 1) break;
+                i++;
+            }
+
+            list.setList(partList);
+            list.setMaxParts(pre.getMaxParts());
+            list.setIsTruncated(partList.size() > pre.getMaxParts());
+            list.setPartNumberMarker(pre.getPartNumberMarker());
+            if (list.getIsTruncated()) {
+                // 删除最后一个多获取的分片信息
+                partList.remove(partList.size() - 1);
+                list.setNextPartNumberMarker(partList.get(partList.size() - 1).getPartNumber());
+            }
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listParts(fileInfo, platform, e);
+        }
+    }
+
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll();
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        Storage client = getClient();
+        try {
+            ArrayList<Storage.BlobListOption> options = new ArrayList<>();
+            options.add(Storage.BlobListOption.pageSize(pre.getMaxFiles()));
+            if (StrUtil.isNotBlank(pre.getMarker())) {
+                options.add(Storage.BlobListOption.pageToken(pre.getMarker()));
+            }
+            options.add(Storage.BlobListOption.delimiter("/"));
+            options.add(Storage.BlobListOption.prefix(basePath + pre.getPath() + pre.getFilenamePrefix()));
+            Page<Blob> result = client.list(bucketName, options.toArray(new Storage.BlobListOption[] {}));
+            ArrayList<Blob> values = ListUtil.toList(result.getValues());
+            ListFilesResult list = new ListFilesResult();
+
+            list.setDirList(values.stream()
+                    .map(item -> {
+                        if (!item.isDirectory()) return null;
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(FileNameUtil.getName(item.getName()));
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.toList()));
+
+            list.setFileList(values.stream()
+                    .map(item -> {
+                        if (item.isDirectory()) return null;
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(FileNameUtil.getName(item.getName()));
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.getSize());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setETag(item.getEtag());
+                        info.setContentDisposition(item.getContentDisposition());
+                        info.setContentType(item.getContentType());
+                        info.setContentMd5(item.getMd5());
+                        info.setLastModified(DateUtil.date(item.getUpdateTimeOffsetDateTime()));
+                        HashMap<String, Object> metadata = new HashMap<>();
+                        if (item.getContentType() != null)
+                            metadata.put(Constant.Metadata.CONTENT_TYPE, item.getContentType());
+                        if (item.getContentEncoding() != null)
+                            metadata.put(Constant.Metadata.CONTENT_ENCODING, item.getContentEncoding());
+                        if (item.getContentDisposition() != null)
+                            metadata.put(Constant.Metadata.CONTENT_DISPOSITION, item.getContentDisposition());
+                        if (item.getContentLanguage() != null)
+                            metadata.put(Constant.Metadata.CONTENT_LANGUAGE, item.getContentLanguage());
+                        if (item.getStorageClass() != null) metadata.put("Storage-Class", item.getStorageClass());
+                        if (item.getSize() != null) metadata.put(Constant.Metadata.CONTENT_LENGTH, item.getSize());
+                        if (item.getMd5() != null) metadata.put(Constant.Metadata.CONTENT_MD5, item.getMd5());
+                        if (item.getEtag() != null) metadata.put("E-Tag", item.getEtag());
+                        if (item.getUpdateTimeOffsetDateTime() != null)
+                            metadata.put(
+                                    Constant.Metadata.LAST_MODIFIED,
+                                    DateUtil.formatHttpDate(DateUtil.date(item.getUpdateTimeOffsetDateTime())));
+                        info.setMetadata(metadata);
+                        if (item.getMetadata() != null) info.setUserMetadata(new HashMap<>(item.getMetadata()));
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .filter(Objects::nonNull)
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(pre.getMaxFiles());
+            list.setIsTruncated(result.hasNextPage());
+            list.setMarker(pre.getMarker());
+            list.setNextMarker(result.getNextPageToken());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        Storage client = getClient();
+        try {
+            Blob file;
+            try {
+                file = client.get(bucketName, fileKey);
+            } catch (Exception e) {
+                return null;
+            }
+            if (file == null) return null;
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(FileNameUtil.getName(file.getName()));
+            info.setUrl(domain + fileKey);
+            info.setSize(file.getSize());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setETag(file.getEtag());
+            info.setContentDisposition(file.getContentDisposition());
+            info.setContentType(file.getContentType());
+            info.setContentMd5(file.getMd5());
+            info.setLastModified(DateUtil.date(file.getUpdateTimeOffsetDateTime()));
+            HashMap<String, Object> metadata = new HashMap<>();
+            if (file.getContentType() != null) metadata.put(Constant.Metadata.CONTENT_TYPE, file.getContentType());
+            if (file.getContentEncoding() != null)
+                metadata.put(Constant.Metadata.CONTENT_ENCODING, file.getContentEncoding());
+            if (file.getContentDisposition() != null)
+                metadata.put(Constant.Metadata.CONTENT_DISPOSITION, file.getContentDisposition());
+            if (file.getContentLanguage() != null)
+                metadata.put(Constant.Metadata.CONTENT_LANGUAGE, file.getContentLanguage());
+            if (file.getStorageClass() != null) metadata.put("Storage-Class", file.getStorageClass());
+            if (file.getSize() != null) metadata.put(Constant.Metadata.CONTENT_LENGTH, file.getSize());
+            if (file.getMd5() != null) metadata.put(Constant.Metadata.CONTENT_MD5, file.getMd5());
+            if (file.getEtag() != null) metadata.put("E-Tag", file.getEtag());
+            if (file.getUpdateTimeOffsetDateTime() != null)
+                metadata.put(
+                        Constant.Metadata.LAST_MODIFIED,
+                        DateUtil.formatHttpDate(DateUtil.date(file.getUpdateTimeOffsetDateTime())));
+            info.setMetadata(metadata);
+            if (file.getMetadata() != null) info.setUserMetadata(new HashMap<>(file.getMetadata()));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     /**
      * 获取文件的访问控制列表，这里又分为 PredefinedAcl 和 List<ACL>
      */
@@ -188,6 +518,28 @@ public void setThMetadata(
         }
     }
 
+    /**
+     * 设置对象的元数据
+     */
+    public void setMetadataOfBlobTargetOption(
+            BlobInfo.Builder blobInfoBuilder, FileInfo fileInfo, ArrayList<Storage.BlobTargetOption> optionList) {
+        blobInfoBuilder.setContentType(fileInfo.getContentType()).setMetadata(fileInfo.getUserMetadata());
+        if (CollUtil.isNotEmpty(fileInfo.getMetadata())) {
+            CopyOptions copyOptions = CopyOptions.create()
+                    .ignoreCase()
+                    .setFieldNameEditor(name -> NamingCase.toCamelCase(name, CharUtil.DASHED));
+            BeanUtil.copyProperties(fileInfo.getMetadata(), blobInfoBuilder, copyOptions);
+        }
+        AclWrapper fileAcl = getAcl(fileInfo.getFileAcl());
+        if (fileAcl != null) {
+            if (fileAcl.getAclList() != null) {
+                blobInfoBuilder.setAcl(fileAcl.getAclList());
+            } else if (fileAcl.getPredefinedAcl() != null) {
+                optionList.add(Storage.BlobTargetOption.predefinedAcl(fileAcl.getPredefinedAcl()));
+            }
+        }
+    }
+
     @Override
     public boolean isSupportAcl() {
         return true;
@@ -239,30 +591,39 @@ public boolean isSupportPresignedUrl() {
     }
 
     @Override
-    public String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
+    public GeneratePresignedUrlResult generatePresignedUrl(GeneratePresignedUrlPretreatment pre) {
         try {
-            BlobInfo blobInfo =
-                    BlobInfo.newBuilder(bucketName, getFileKey(fileInfo)).build();
-            long duration = expiration.getTime() - System.currentTimeMillis();
-            return getClient()
-                    .signUrl(blobInfo, duration, TimeUnit.MILLISECONDS)
-                    .toString();
-        } catch (Exception e) {
-            throw ExceptionFactory.generatePresignedUrl(fileInfo, platform, e);
-        }
-    }
-
-    @Override
-    public String generateThPresignedUrl(FileInfo fileInfo, Date expiration) {
-        try {
-            BlobInfo blobInfo =
-                    BlobInfo.newBuilder(bucketName, getThFileKey(fileInfo)).build();
-            long duration = expiration.getTime() - System.currentTimeMillis();
-            return getClient()
-                    .signUrl(blobInfo, duration, TimeUnit.MILLISECONDS)
-                    .toString();
+            BlobInfo blobInfo = BlobInfo.newBuilder(
+                            bucketName, getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename())))
+                    .setMetadata(pre.getUserMetadata())
+                    .build();
+            long duration = pre.getExpiration().getTime() - System.currentTimeMillis();
+            ArrayList<SignUrlOption> signUrlOptionList = new ArrayList<>();
+            signUrlOptionList.add(SignUrlOption.withV4Signature());
+            if (pre.getMethod() instanceof HttpMethod) {
+                signUrlOptionList.add(SignUrlOption.httpMethod((HttpMethod) pre.getMethod()));
+            } else {
+                signUrlOptionList.add(SignUrlOption.httpMethod(
+                        HttpMethod.valueOf(String.valueOf(pre.getMethod()).toUpperCase())));
+            }
+            HashMap<String, String> queryParams = new HashMap<>(pre.getQueryParams());
+            pre.getResponseHeaders().forEach((k, v) -> queryParams.put("response-" + k.toLowerCase(), v));
+            signUrlOptionList.add(SignUrlOption.withQueryParams(queryParams));
+            Map<String, String> headers = new HashMap<>(pre.getHeaders());
+            headers.putAll(pre.getUserMetadata().entrySet().stream()
+                    .collect(Collectors.toMap(
+                            e -> e.getKey().startsWith("x-goog-meta-") ? e.getKey() : "x-goog-meta-" + e.getKey(),
+                            Map.Entry::getValue)));
+            signUrlOptionList.add(SignUrlOption.withExtHeaders(headers));
+            URL url = getClient()
+                    .signUrl(
+                            blobInfo, duration, TimeUnit.MILLISECONDS, signUrlOptionList.toArray(new SignUrlOption[0]));
+            GeneratePresignedUrlResult result = new GeneratePresignedUrlResult(platform, basePath, pre);
+            result.setUrl(url.toString());
+            result.setHeaders(headers);
+            return result;
         } catch (Exception e) {
-            throw ExceptionFactory.generateThPresignedUrl(fileInfo, platform, e);
+            throw ExceptionFactory.generatePresignedUrl(pre, e);
         }
     }
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/HuaweiObsFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/HuaweiObsFileStorage.java
index c5202eb0..bb68bc1e 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/HuaweiObsFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/HuaweiObsFileStorage.java
@@ -4,6 +4,7 @@
 import cn.hutool.core.bean.copier.CopyOptions;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.io.file.FileNameUtil;
 import cn.hutool.core.text.NamingCase;
 import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.util.StrUtil;
@@ -12,9 +13,7 @@
 import com.obs.services.model.*;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
@@ -30,7 +29,11 @@
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.get.*;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.upload.*;
+import org.dromara.x.file.storage.core.util.Tools;
 
 /**
  * 华为云 OBS 存储
@@ -263,6 +266,108 @@ public FilePartInfoList listParts(ListPartsPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll();
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        ObsClient client = getClient();
+        try {
+            ListObjectsRequest request = new ListObjectsRequest(bucketName);
+            request.setMaxKeys(pre.getMaxFiles());
+            request.setMarker(pre.getMarker());
+            request.setDelimiter("/");
+            request.setPrefix(basePath + pre.getPath() + pre.getFilenamePrefix());
+            ObjectListing result = client.listObjects(request);
+            ListFilesResult list = new ListFilesResult();
+
+            list.setDirList(result.getCommonPrefixes().stream()
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(FileNameUtil.getName(item));
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+
+            list.setFileList(result.getObjects().stream()
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(FileNameUtil.getName(item.getObjectKey()));
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        ObjectMetadata metadata = item.getMetadata();
+                        info.setSize(metadata.getContentLength());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setETag(metadata.getEtag());
+                        info.setContentDisposition(metadata.getContentDisposition());
+                        info.setContentType(metadata.getContentType());
+                        info.setContentMd5(metadata.getContentMd5());
+                        info.setLastModified(metadata.getLastModified());
+                        info.setMetadata(BeanUtil.beanToMap(metadata, false, true));
+                        info.setUserMetadata(BeanUtil.beanToMap(metadata.getAllMetadata()));
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(result.getMaxKeys());
+            list.setIsTruncated(result.isTruncated());
+            list.setMarker(result.getMarker());
+            list.setNextMarker(result.getNextMarker());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        ObsClient client = getClient();
+        try {
+            ObsObject file;
+            try {
+                file = client.getObject(bucketName, fileKey);
+            } catch (Exception e) {
+                return null;
+            }
+            if (file == null) return null;
+            ObjectMetadata metadata = file.getMetadata();
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(FileNameUtil.getName(file.getObjectKey()));
+            info.setUrl(domain + fileKey);
+            info.setSize(metadata.getContentLength());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setETag(metadata.getEtag());
+            info.setContentDisposition(metadata.getContentDisposition());
+            info.setContentType(metadata.getContentType());
+            info.setContentMd5(metadata.getContentMd5());
+            info.setLastModified(metadata.getLastModified());
+            info.setMetadata(BeanUtil.beanToMap(metadata, false, true));
+            info.getMetadata().remove("userMetadata");
+            info.getMetadata().put("eTag", metadata.getEtag());
+            info.setUserMetadata(new HashMap<>(metadata.getAllMetadata()));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     /**
      * 获取文件的访问控制列表
      */
@@ -319,31 +424,31 @@ public boolean isSupportPresignedUrl() {
     }
 
     @Override
-    public String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
+    public GeneratePresignedUrlResult generatePresignedUrl(GeneratePresignedUrlPretreatment pre) {
         try {
-            long expires = (expiration.getTime() - System.currentTimeMillis()) / 1000;
-            TemporarySignatureRequest request = new TemporarySignatureRequest(HttpMethodEnum.GET, expires);
+            HttpMethodEnum method = Tools.getEnum(HttpMethodEnum.class, pre.getMethod());
+            SpecialParamEnum specialParam = Tools.getEnum(SpecialParamEnum.class, pre.getSpecialParam());
+            long expires = (pre.getExpiration().getTime() - System.currentTimeMillis()) / 1000;
+            TemporarySignatureRequest request = new TemporarySignatureRequest(method, expires);
             request.setBucketName(bucketName);
-            request.setObjectKey(getFileKey(fileInfo));
-            return getClient().createTemporarySignature(request).getSignedUrl();
-        } catch (Exception e) {
-            throw ExceptionFactory.generatePresignedUrl(fileInfo, platform, e);
-        }
-    }
-
-    @Override
-    public String generateThPresignedUrl(FileInfo fileInfo, Date expiration) {
-        try {
-            String key = getThFileKey(fileInfo);
-            if (key == null) return null;
-            long expires = (expiration.getTime() - System.currentTimeMillis()) / 1000;
-            TemporarySignatureRequest request = new TemporarySignatureRequest(HttpMethodEnum.GET, expires);
-            request.setBucketName(bucketName);
-            request.setObjectKey(key);
-
-            return getClient().createTemporarySignature(request).getSignedUrl();
+            request.setObjectKey(getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename())));
+            request.setSpecialParam(specialParam);
+            Map<String, String> headers = new HashMap<>(pre.getHeaders());
+            headers.putAll(pre.getUserMetadata().entrySet().stream()
+                    .collect(Collectors.toMap(
+                            e -> e.getKey().startsWith("x-obs-meta-") ? e.getKey() : "x-obs-meta-" + e.getKey(),
+                            Map.Entry::getValue)));
+            request.setHeaders(headers);
+            HashMap<String, Object> queryParam = new HashMap<>(pre.getQueryParams());
+            pre.getResponseHeaders().forEach((k, v) -> queryParam.put("response-" + k.toLowerCase(), v));
+            request.setQueryParams(queryParam);
+            GeneratePresignedUrlResult result = new GeneratePresignedUrlResult(platform, basePath, pre);
+            TemporarySignatureResponse response = getClient().createTemporarySignature(request);
+            result.setUrl(response.getSignedUrl());
+            result.setHeaders(response.getActualSignedRequestHeaders());
+            return result;
         } catch (Exception e) {
-            throw ExceptionFactory.generateThPresignedUrl(fileInfo, platform, e);
+            throw ExceptionFactory.generatePresignedUrl(pre, e);
         }
     }
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/LocalFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/LocalFileStorage.java
index 3d2c237d..bfab21d5 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/LocalFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/LocalFileStorage.java
@@ -3,6 +3,7 @@
 import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IoUtil;
 import cn.hutool.core.io.StreamProgress;
+import cn.hutool.core.io.file.FileNameUtil;
 import cn.hutool.core.util.IdUtil;
 import cn.hutool.core.util.StrUtil;
 import java.io.BufferedOutputStream;
@@ -10,6 +11,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.StandardCopyOption;
+import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Date;
 import java.util.List;
@@ -25,6 +27,7 @@
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.get.*;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
 import org.dromara.x.file.storage.core.upload.*;
 import org.dromara.x.file.storage.core.util.Tools;
@@ -118,7 +121,7 @@ public void initiateMultipartUpload(FileInfo fileInfo, InitiateMultipartUploadPr
         try {
             String uploadId = IdUtil.objectId();
             String parent = FileUtil.file(getAbsolutePath(newFileKey)).getParent();
-            FileUtil.mkdir(FileUtil.file(parent, uploadId));
+            FileUtil.touch(parent, uploadId + "/index");
             fileInfo.setUploadId(uploadId);
         } catch (Exception e) {
             throw ExceptionFactory.initiateMultipartUpload(fileInfo, platform, e);
@@ -270,6 +273,85 @@ public FilePartInfoList listParts(ListPartsPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll().setSupportMaxFiles(Integer.MAX_VALUE);
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        try {
+            String path = getAbsolutePath(basePath + pre.getPath());
+            List<File> fileList = Arrays.stream(FileUtil.isDirectory(path) ? FileUtil.ls(path) : new File[0])
+                    .filter(f -> f.isFile() || f.isDirectory())
+                    .collect(Collectors.toList());
+            ListFilesMatchResult<File> matchResult = listFilesMatch(fileList, File::getName, pre, false);
+            ListFilesResult list = new ListFilesResult();
+            list.setDirList(matchResult.getList().stream()
+                    .filter(File::isDirectory)
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(item.getName());
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+            list.setFileList(matchResult.getList().stream()
+                    .filter(File::isFile)
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(item.getName());
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.length());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setLastModified(new Date(item.lastModified()));
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(pre.getMaxFiles());
+            list.setIsTruncated(matchResult.getIsTruncated());
+            list.setMarker(pre.getMarker());
+            list.setNextMarker(matchResult.getNextMarker());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        try {
+            File file = new File(getAbsolutePath(fileKey));
+            if (!file.exists()) return null;
+            if (!file.isFile()) return null;
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(file.getName());
+            info.setUrl(domain + fileKey);
+            info.setSize(file.length());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setLastModified(new Date(file.lastModified()));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     @Override
     public boolean delete(FileInfo fileInfo) {
         try {
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/LocalPlusFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/LocalPlusFileStorage.java
index 889b39ea..3a68065f 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/LocalPlusFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/LocalPlusFileStorage.java
@@ -3,6 +3,7 @@
 import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IoUtil;
 import cn.hutool.core.io.StreamProgress;
+import cn.hutool.core.io.file.FileNameUtil;
 import cn.hutool.core.util.IdUtil;
 import cn.hutool.core.util.StrUtil;
 import java.io.BufferedOutputStream;
@@ -10,9 +11,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.file.StandardCopyOption;
-import java.util.Comparator;
-import java.util.Date;
-import java.util.List;
+import java.util.*;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import lombok.*;
@@ -25,6 +24,7 @@
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.get.*;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
 import org.dromara.x.file.storage.core.upload.*;
 
@@ -107,7 +107,7 @@ public void initiateMultipartUpload(FileInfo fileInfo, InitiateMultipartUploadPr
         try {
             String uploadId = IdUtil.objectId();
             String parent = FileUtil.file(getAbsolutePath(newFileKey)).getParent();
-            FileUtil.mkdir(FileUtil.file(parent, uploadId));
+            FileUtil.touch(parent, uploadId + "/index");
             fileInfo.setUploadId(uploadId);
         } catch (Exception e) {
             throw ExceptionFactory.initiateMultipartUpload(fileInfo, platform, e);
@@ -259,6 +259,85 @@ public FilePartInfoList listParts(ListPartsPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll().setSupportMaxFiles(Integer.MAX_VALUE);
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        try {
+            String path = getAbsolutePath(basePath + pre.getPath());
+            List<File> fileList = Arrays.stream(FileUtil.isDirectory(path) ? FileUtil.ls(path) : new File[0])
+                    .filter(f -> f.isFile() || f.isDirectory())
+                    .collect(Collectors.toList());
+            ListFilesMatchResult<File> matchResult = listFilesMatch(fileList, File::getName, pre, false);
+            ListFilesResult list = new ListFilesResult();
+            list.setDirList(matchResult.getList().stream()
+                    .filter(File::isDirectory)
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(item.getName());
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+            list.setFileList(matchResult.getList().stream()
+                    .filter(File::isFile)
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(item.getName());
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.length());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setLastModified(new Date(item.lastModified()));
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(pre.getMaxFiles());
+            list.setIsTruncated(matchResult.getIsTruncated());
+            list.setMarker(pre.getMarker());
+            list.setNextMarker(matchResult.getNextMarker());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        try {
+            File file = new File(getAbsolutePath(fileKey));
+            if (!file.exists()) return null;
+            if (!file.isFile()) return null;
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(file.getName());
+            info.setUrl(domain + fileKey);
+            info.setSize(file.length());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setLastModified(new Date(file.lastModified()));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     @Override
     public boolean delete(FileInfo fileInfo) {
         try {
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/MinioFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/MinioFileStorage.java
index 2ef3d3d0..76e6b4b3 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/MinioFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/MinioFileStorage.java
@@ -1,12 +1,16 @@
 package org.dromara.x.file.storage.core.platform;
 
+import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.io.file.FileNameUtil;
+import cn.hutool.core.map.MapProxy;
 import cn.hutool.core.util.ReflectUtil;
 import cn.hutool.core.util.StrUtil;
 import com.google.common.collect.Multimap;
 import io.minio.*;
 import io.minio.errors.ErrorResponseException;
 import io.minio.http.Method;
+import io.minio.messages.ListBucketResultV1;
 import io.minio.messages.ListPartsResult;
 import io.minio.messages.Part;
 import java.io.ByteArrayInputStream;
@@ -32,7 +36,11 @@
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.get.*;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.upload.*;
+import org.dromara.x.file.storage.core.util.KebabCaseInsensitiveMap;
 import org.dromara.x.file.storage.core.util.Tools;
 
 /**
@@ -176,7 +184,7 @@ public void initiateMultipartUpload(FileInfo fileInfo, InitiateMultipartUploadPr
      * 通过反射调用内部的上传分片方法
      */
     public UploadPartResponse uploadPart(MinioClient client, String uploadId, int partNumber, PutObjectArgs args)
-            throws ExecutionException, InterruptedException {
+            throws ExecutionException, InterruptedException, NoSuchMethodException {
         MinioAsyncClient asyncClient = getMinioAsyncClient(client);
 
         java.lang.reflect.Method newPartReaderMethod =
@@ -186,11 +194,19 @@ public UploadPartResponse uploadPart(MinioClient client, String uploadId, int pa
                 asyncClient, newPartReaderMethod, args.stream(), args.objectSize(), args.partSize(), 1);
         Object partSource = ReflectUtil.invoke(partReader, "getPart");
 
-        java.lang.reflect.Method uploadPartsMethod =
-                ReflectUtil.getMethodByName(asyncClient.getClass(), "uploadPartAsync");
+        java.lang.reflect.Method[] uploadPartsMethods = ReflectUtil.getMethods(
+                asyncClient.getClass(),
+                method -> StrUtil.equalsIgnoreCase(method.getName(), "uploadPartAsync") // 方法名称是 uploadPartAsync
+                        && method.getParameterTypes().length == 8 // 参数个数是8个
+                        && StrUtil.equals(
+                                method.getParameterTypes()[3].getSimpleName(), "PartSource") // 且第4个参数的类名称是 PartSource
+                );
+        if (uploadPartsMethods == null || uploadPartsMethods.length != 1) {
+            throw new NoSuchMethodException("MinioAsyncClient uploadPartAsync method not find");
+        }
         CompletableFuture<UploadPartResponse> result = ReflectUtil.invoke(
                 asyncClient,
-                uploadPartsMethod,
+                uploadPartsMethods[0],
                 args.bucket(),
                 args.region(),
                 args.object(),
@@ -362,41 +378,174 @@ public FilePartInfoList listParts(ListPartsPretreatment pre) {
     }
 
     @Override
-    public boolean isSupportPresignedUrl() {
-        return true;
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll();
+    }
+
+    /**
+     * 通过反射调用内部的列举文件方法
+     */
+    public ListBucketResultV1 listFiles(MinioClient client, ListObjectsArgs args)
+            throws ExecutionException, InterruptedException {
+        MinioAsyncClient asyncClient = getMinioAsyncClient(client);
+        java.lang.reflect.Method method = ReflectUtil.getMethod(
+                asyncClient.getClass(),
+                "listObjectsV1",
+                String.class,
+                String.class,
+                String.class,
+                String.class,
+                String.class,
+                Integer.class,
+                String.class,
+                Multimap.class,
+                Multimap.class);
+        ListObjectsV1Response result = ReflectUtil.invoke(
+                asyncClient,
+                method,
+                args.bucket(),
+                args.region(),
+                args.delimiter(),
+                args.useUrlEncodingType() ? "url" : null,
+                args.marker(),
+                args.maxKeys(),
+                args.prefix(),
+                args.extraHeaders(),
+                args.extraQueryParams());
+        return result.result();
     }
 
     @Override
-    public String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
-        int expiry = (int) ((expiration.getTime() - System.currentTimeMillis()) / 1000);
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        MinioClient client = getClient();
         try {
-            GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder()
+            ListObjectsArgs args = ListObjectsArgs.builder()
                     .bucket(bucketName)
-                    .object(getFileKey(fileInfo))
-                    .method(Method.GET)
-                    .expiry(expiry)
+                    .maxKeys(pre.getMaxFiles())
+                    .marker(pre.getMarker())
+                    .delimiter("/")
+                    .prefix(basePath + pre.getPath() + pre.getFilenamePrefix())
                     .build();
-            return getClient().getPresignedObjectUrl(args);
+            ListBucketResultV1 result = listFiles(client, args);
+            ListFilesResult list = new ListFilesResult();
+            list.setDirList(result.commonPrefixes().stream()
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(FileNameUtil.getName(item.toItem().objectName()));
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+
+            list.setFileList(result.contents().stream()
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(FileNameUtil.getName(item.objectName()));
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.size());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setETag(item.etag());
+                        info.setLastModified(DateUtil.date(item.lastModified()));
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(result.maxKeys());
+            list.setIsTruncated(result.isTruncated());
+            list.setMarker(result.marker());
+            list.setNextMarker(result.nextMarker());
+            return list;
         } catch (Exception e) {
-            throw ExceptionFactory.generatePresignedUrl(fileInfo, platform, e);
+            throw ExceptionFactory.listFiles(pre, basePath, e);
         }
     }
 
     @Override
-    public String generateThPresignedUrl(FileInfo fileInfo, Date expiration) {
-        String key = getThFileKey(fileInfo);
-        if (key == null) return null;
-        int expiry = (int) ((expiration.getTime() - System.currentTimeMillis()) / 1000);
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        MinioClient client = getClient();
+        try {
+            StatObjectResponse file;
+            try {
+                file = client.statObject(StatObjectArgs.builder()
+                        .bucket(bucketName)
+                        .object(fileKey)
+                        .build());
+            } catch (Exception e) {
+                return null;
+            }
+            if (file == null) return null;
+
+            KebabCaseInsensitiveMap<String, String> headers =
+                    new KebabCaseInsensitiveMap<>(file.headers().toMultimap().entrySet().stream()
+                            .collect(Collectors.toMap(Map.Entry::getKey, e -> CollUtil.get(e.getValue(), 0))));
+            MapProxy headersProxy = MapProxy.create(headers);
+
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(FileNameUtil.getName(file.object()));
+            info.setUrl(domain + fileKey);
+            info.setSize(file.size());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setETag(file.etag());
+            info.setContentDisposition(headersProxy.getStr(Constant.Metadata.CONTENT_DISPOSITION));
+            info.setContentType(file.contentType());
+            info.setContentMd5(headersProxy.getStr(Constant.Metadata.CONTENT_MD5));
+            info.setLastModified(DateUtil.date(file.lastModified()));
+            info.setMetadata(headers.entrySet().stream()
+                    .filter(e -> !e.getKey().startsWith("x-amz-meta-"))
+                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
+            if (file.userMetadata() != null) info.setUserMetadata(new HashMap<>(file.userMetadata()));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public boolean isSupportPresignedUrl() {
+        return true;
+    }
+
+    @Override
+    public GeneratePresignedUrlResult generatePresignedUrl(GeneratePresignedUrlPretreatment pre) {
         try {
+            String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+            Map<String, String> headers = new HashMap<>(pre.getHeaders());
+            headers.putAll(pre.getUserMetadata().entrySet().stream()
+                    .collect(Collectors.toMap(
+                            e -> e.getKey().startsWith("x-amz-meta-") ? e.getKey() : "x-amz-meta-" + e.getKey(),
+                            Map.Entry::getValue)));
+            HashMap<String, String> queryParam = new HashMap<>(pre.getQueryParams());
+            pre.getResponseHeaders().forEach((k, v) -> queryParam.put("response-" + k.toLowerCase(), v));
             GetPresignedObjectUrlArgs args = GetPresignedObjectUrlArgs.builder()
                     .bucket(bucketName)
-                    .object(key)
-                    .method(Method.GET)
-                    .expiry(expiry)
+                    .object(fileKey)
+                    .method(Tools.getEnum(Method.class, pre.getMethod()))
+                    .expiry((int) ((pre.getExpiration().getTime() - System.currentTimeMillis()) / 1000))
+                    .extraHeaders(headers)
+                    .extraQueryParams(queryParam)
                     .build();
-            return getClient().getPresignedObjectUrl(args);
+            String url = getClient().getPresignedObjectUrl(args);
+            GeneratePresignedUrlResult result = new GeneratePresignedUrlResult(platform, basePath, pre);
+            result.setUrl(url);
+            result.setHeaders(headers);
+            return result;
         } catch (Exception e) {
-            throw ExceptionFactory.generateThPresignedUrl(fileInfo, platform, e);
+            throw ExceptionFactory.generatePresignedUrl(pre, e);
         }
     }
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/QiniuKodoFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/QiniuKodoFileStorage.java
index 40468ad1..d3bb8676 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/QiniuKodoFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/QiniuKodoFileStorage.java
@@ -2,10 +2,13 @@
 
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.io.file.FileNameUtil;
 import cn.hutool.core.lang.Dict;
 import cn.hutool.core.util.StrUtil;
 import com.qiniu.common.QiniuException;
 import com.qiniu.storage.*;
+import com.qiniu.storage.model.FileListing;
 import com.qiniu.util.StringMap;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
@@ -21,11 +24,16 @@
 import org.dromara.x.file.storage.core.InputStreamPlus;
 import org.dromara.x.file.storage.core.ProgressListener;
 import org.dromara.x.file.storage.core.UploadPretreatment;
+import org.dromara.x.file.storage.core.constant.Constant;
 import org.dromara.x.file.storage.core.copy.CopyPretreatment;
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
+import org.dromara.x.file.storage.core.exception.FileStorageRuntimeException;
+import org.dromara.x.file.storage.core.get.*;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
 import org.dromara.x.file.storage.core.platform.QiniuKodoFileStorageClientFactory.QiniuKodoClient;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.upload.*;
 
 /**
@@ -175,7 +183,7 @@ public void completeMultipartUpload(CompleteMultipartUploadPretreatment pre) {
                     host -> {
                         ApiUploadV2CompleteUpload api = new ApiUploadV2CompleteUpload(client.getClient());
                         ApiUploadV2CompleteUpload.Request request = new ApiUploadV2CompleteUpload.Request(
-                                        "https://upload-z2.qiniup.com", token, fileInfo.getUploadId(), partsInfo)
+                                        host, token, fileInfo.getUploadId(), partsInfo)
                                 .setKey(newFileKey)
                                 .setFileMimeType(fileInfo.getContentType())
                                 .setFileName(null)
@@ -203,7 +211,7 @@ public void abortMultipartUpload(AbortMultipartUploadPretreatment pre) {
                     host -> {
                         ApiUploadV2AbortUpload api = new ApiUploadV2AbortUpload(client.getClient());
                         ApiUploadV2AbortUpload.Request request = new ApiUploadV2AbortUpload.Request(
-                                        "https://upload-z2.qiniup.com", token, fileInfo.getUploadId())
+                                        host, token, fileInfo.getUploadId())
                                 .setKey(newFileKey);
                         ApiUploadV2AbortUpload.Response response = api.request(request);
                         return new QiniuKodoClient.UploadActionResult<>(response.getResponse(), response);
@@ -221,14 +229,21 @@ public FilePartInfoList listParts(ListPartsPretreatment pre) {
         QiniuKodoClient client = getClient();
         try {
             String token = client.getAuth().uploadToken(bucketName);
-            ApiUploadV2ListParts api = new ApiUploadV2ListParts(client.getClient());
-            ApiUploadV2ListParts.Request request = new ApiUploadV2ListParts.Request(
-                            "https://upload-z2.qiniup.com", token, fileInfo.getUploadId())
-                    .setKey(newFileKey)
-                    .setMaxParts(pre.getMaxParts())
-                    .setPartNumberMarker(pre.getPartNumberMarker());
-            ApiUploadV2ListParts.Response response = api.request(request);
+            QiniuKodoClient.UploadActionResult<ApiUploadV2ListParts.Response> result = client.retryUploadAction(
+                    host -> {
+                        ApiUploadV2ListParts api = new ApiUploadV2ListParts(client.getClient());
+                        ApiUploadV2ListParts.Request request = new ApiUploadV2ListParts.Request(
+                                        host, token, fileInfo.getUploadId())
+                                .setKey(newFileKey)
+                                .setMaxParts(pre.getMaxParts())
+                                .setPartNumberMarker(pre.getPartNumberMarker());
+                        ApiUploadV2ListParts.Response response = api.request(request);
+                        return new QiniuKodoClient.UploadActionResult<>(response.getResponse(), response);
+                    },
+                    token);
+            ApiUploadV2ListParts.Response response = result.getData();
             List<?> parts = response.getParts();
+            if (parts == null) parts = Collections.emptyList();
             FilePartInfoList list = new FilePartInfoList();
             list.setFileInfo(fileInfo);
             list.setList(parts.stream()
@@ -252,6 +267,114 @@ public FilePartInfoList listParts(ListPartsPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll();
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        BucketManager manager = getClient().getBucketManager();
+        try {
+            FileListing result = manager.listFilesV2(
+                    bucketName,
+                    basePath + pre.getPath() + pre.getFilenamePrefix(),
+                    pre.getMarker(),
+                    pre.getMaxFiles(),
+                    "/");
+            ListFilesResult list = new ListFilesResult();
+            list.setDirList(Arrays.stream(result.commonPrefixes)
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(FileNameUtil.getName(item));
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+            list.setFileList(Arrays.stream(result.items)
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(FileNameUtil.getName(item.key));
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.fsize);
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setContentType(item.mimeType);
+                        info.setContentMd5(item.md5);
+                        info.setLastModified(new Date(item.putTime / 10000));
+                        HashMap<String, Object> metadata = new HashMap<>();
+                        metadata.put(Constant.Metadata.CONTENT_LENGTH, item.fsize);
+                        if (item.mimeType != null) metadata.put(Constant.Metadata.CONTENT_TYPE, item.mimeType);
+                        if (item.md5 != null) metadata.put(Constant.Metadata.CONTENT_MD5, item.md5);
+                        metadata.put(Constant.Metadata.LAST_MODIFIED, info.getLastModified());
+                        if (item.expiration != null)
+                            metadata.put(
+                                    Constant.Metadata.EXPIRES,
+                                    DateUtil.formatHttpDate(new Date(item.expiration * 1000)));
+                        info.setMetadata(metadata);
+                        info.setUserMetadata(item.meta);
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(pre.getMaxFiles());
+            list.setIsTruncated(!result.isEOF());
+            list.setMarker(pre.getMarker());
+            list.setNextMarker(result.marker);
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        QiniuKodoClient client = getClient();
+        try {
+            com.qiniu.storage.model.FileInfo file;
+            try {
+                file = client.getBucketManager().stat(bucketName, fileKey);
+            } catch (Exception e) {
+                return null;
+            }
+            if (file == null) return null;
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(FileNameUtil.getName(file.key));
+            info.setUrl(domain + fileKey);
+            info.setSize(file.fsize);
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setContentType(file.mimeType);
+            info.setContentMd5(file.md5);
+            info.setLastModified(new Date(file.putTime / 10000));
+            HashMap<String, Object> metadata = new HashMap<>();
+            metadata.put(Constant.Metadata.CONTENT_LENGTH, file.fsize);
+            if (file.mimeType != null) metadata.put(Constant.Metadata.CONTENT_TYPE, file.mimeType);
+            if (file.md5 != null) metadata.put(Constant.Metadata.CONTENT_MD5, file.md5);
+            metadata.put(Constant.Metadata.LAST_MODIFIED, info.getLastModified());
+            if (file.expiration != null)
+                metadata.put(Constant.Metadata.EXPIRES, DateUtil.formatHttpDate(new Date(file.expiration * 1000)));
+            info.setMetadata(metadata);
+            info.setUserMetadata(file.meta);
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     /**
      * 获取对象的元数据
      */
@@ -290,23 +413,20 @@ public boolean isSupportPresignedUrl() {
     }
 
     @Override
-    public String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
+    public GeneratePresignedUrlResult generatePresignedUrl(GeneratePresignedUrlPretreatment pre) {
         try {
-            int deadline = (int) (expiration.getTime() / 1000);
-            return getClient().getAuth().privateDownloadUrlWithDeadline(fileInfo.getUrl(), deadline);
-        } catch (Exception e) {
-            throw ExceptionFactory.generatePresignedUrl(fileInfo, platform, e);
-        }
-    }
-
-    @Override
-    public String generateThPresignedUrl(FileInfo fileInfo, Date expiration) {
-        try {
-            if (StrUtil.isBlank(fileInfo.getThUrl())) return null;
-            int deadline = (int) (expiration.getTime() / 1000);
-            return getClient().getAuth().privateDownloadUrlWithDeadline(fileInfo.getThUrl(), deadline);
+            if (Constant.GeneratePresignedUrl.Method.GET.equalsIgnoreCase(String.valueOf(pre.getMethod()))) {
+                throw new FileStorageRuntimeException("七牛云 Kode 仅支持 GET ，如需支持更多功能，可以通过 AWS S3 的 SDK 来使用");
+            }
+            String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+            int deadline = (int) (pre.getExpiration().getTime() / 1000);
+            String url = getClient().getAuth().privateDownloadUrlWithDeadline(domain + fileKey, deadline);
+            GeneratePresignedUrlResult result = new GeneratePresignedUrlResult(platform, basePath, pre);
+            result.setUrl(url);
+            result.setHeaders(new HashMap<>());
+            return result;
         } catch (Exception e) {
-            throw ExceptionFactory.generateThPresignedUrl(fileInfo, platform, e);
+            throw ExceptionFactory.generatePresignedUrl(pre, e);
         }
     }
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/SftpFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/SftpFileStorage.java
index 3f1d25d8..f7bcc884 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/SftpFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/SftpFileStorage.java
@@ -2,16 +2,23 @@
 
 import static com.jcraft.jsch.ChannelSftp.SSH_FX_NO_SUCH_FILE;
 
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.io.file.FileNameUtil;
+import cn.hutool.core.util.ReflectUtil;
 import cn.hutool.core.util.StrUtil;
 import cn.hutool.extra.ssh.JschRuntimeException;
 import cn.hutool.extra.ssh.Sftp;
 import com.jcraft.jsch.ChannelSftp;
+import com.jcraft.jsch.ChannelSftp.LsEntry;
 import com.jcraft.jsch.SftpATTRS;
 import com.jcraft.jsch.SftpException;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.List;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
@@ -22,6 +29,7 @@
 import org.dromara.x.file.storage.core.UploadPretreatment;
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
+import org.dromara.x.file.storage.core.get.*;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
 
 /**
@@ -107,6 +115,123 @@ public boolean save(FileInfo fileInfo, UploadPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll().setSupportMaxFiles(Integer.MAX_VALUE);
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        Sftp client = getClient();
+        try {
+            String path = getAbsolutePath(basePath + pre.getPath());
+            List<LsEntry> fileList = Collections.emptyList();
+            if (client.isDir(path)) {
+                fileList = client.lsEntries(path).stream()
+                        .filter(item ->
+                                item.getAttrs().isDir() || item.getAttrs().isReg())
+                        .collect(Collectors.toList());
+            }
+            ListFilesMatchResult<LsEntry> matchResult = listFilesMatch(fileList, LsEntry::getFilename, pre, true);
+            ListFilesResult list = new ListFilesResult();
+            list.setDirList(matchResult.getList().stream()
+                    .filter(item -> item.getAttrs().isDir())
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(item.getFilename());
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+            list.setFileList(matchResult.getList().stream()
+                    .filter(item -> item.getAttrs().isReg())
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(item.getFilename());
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.getAttrs().getSize());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setLastModified(DateUtil.date(item.getAttrs().getMTime() * 1000L));
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(pre.getMaxFiles());
+            list.setIsTruncated(matchResult.getIsTruncated());
+            list.setMarker(pre.getMarker());
+            list.setNextMarker(matchResult.getNextMarker());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        } finally {
+            returnClient(client);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        Sftp client = getClient();
+        try {
+            String path = getAbsolutePath(basePath + pre.getPath());
+            String filename = pre.getFilename();
+
+            // 这种方式速度慢，列举文件接口返回数据相同
+            //            final LsEntry[] files = {null};
+            //            if (client.isDir(path)) {
+            //                client.getClient().ls(path, entry -> {
+            //                    if (pre.getFilename().equals(entry.getFilename())) {
+            //                        files[0] = entry;
+            //                        return ChannelSftp.LsEntrySelector.BREAK;
+            //                    }
+            //                    return ChannelSftp.LsEntrySelector.CONTINUE;
+            //                });
+            //            }
+            //            LsEntry file = files[0];
+            //            if (file == null) return null;
+
+            // 这种方式速度快，但是 longname 与列举文件方法返回的 longname 不相同，
+            // 可以使用列举文件方法代替：fileStorageService.listFiles().setPath("test/").setFilenamePrefix("a.jpg").setMaxFiles(1).listFiles();
+            SftpATTRS attrs;
+            try {
+                attrs = client.getClient().stat(path + filename);
+            } catch (Exception e) {
+                return null;
+            }
+            if (attrs == null) return null;
+            LsEntry file = ReflectUtil.newInstanceIfPossible(LsEntry.class);
+            ReflectUtil.setFieldValue(file, "filename", filename);
+            ReflectUtil.setFieldValue(file, "longname", attrs + " " + filename);
+            ReflectUtil.setFieldValue(file, "attrs", attrs);
+
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(file.getFilename());
+            info.setUrl(domain + fileKey);
+            info.setSize(file.getAttrs().getSize());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setLastModified(DateUtil.date(file.getAttrs().getMTime() * 1000L));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        } finally {
+            returnClient(client);
+        }
+    }
+
     @Override
     public boolean delete(FileInfo fileInfo) {
         Sftp client = getClient();
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/TencentCosFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/TencentCosFileStorage.java
index 05904da7..1ffa2575 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/TencentCosFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/TencentCosFileStorage.java
@@ -2,15 +2,16 @@
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.io.file.FileNameUtil;
 import cn.hutool.core.util.StrUtil;
 import com.qcloud.cos.COSClient;
 import com.qcloud.cos.event.ProgressEventType;
+import com.qcloud.cos.http.HttpMethodName;
 import com.qcloud.cos.model.*;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
+import java.net.URL;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
@@ -26,6 +27,9 @@
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.get.*;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.upload.*;
 import org.dromara.x.file.storage.core.util.Tools;
 
@@ -269,6 +273,101 @@ public FilePartInfoList listParts(ListPartsPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll();
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        COSClient client = getClient();
+        try {
+            ListObjectsRequest request = new ListObjectsRequest();
+            request.setBucketName(bucketName);
+            request.setMaxKeys(pre.getMaxFiles());
+            request.setMarker(pre.getMarker());
+            request.setDelimiter("/");
+            request.setPrefix(basePath + pre.getPath() + pre.getFilenamePrefix());
+            ObjectListing result = client.listObjects(request);
+            ListFilesResult list = new ListFilesResult();
+
+            list.setDirList(result.getCommonPrefixes().stream()
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(FileNameUtil.getName(item));
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+
+            list.setFileList(result.getObjectSummaries().stream()
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(FileNameUtil.getName(item.getKey()));
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.getSize());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setETag(item.getETag());
+                        info.setLastModified(item.getLastModified());
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(result.getMaxKeys());
+            list.setIsTruncated(result.isTruncated());
+            list.setMarker(result.getMarker());
+            list.setNextMarker(result.getNextMarker());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        COSClient client = getClient();
+        try {
+            COSObject file;
+            try {
+                file = client.getObject(bucketName, fileKey);
+            } catch (Exception e) {
+                return null;
+            }
+            if (file == null) return null;
+            ObjectMetadata metadata = file.getObjectMetadata();
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(FileNameUtil.getName(file.getKey()));
+            info.setUrl(domain + fileKey);
+            info.setSize(metadata.getContentLength());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setETag(metadata.getETag());
+            info.setContentDisposition(metadata.getContentDisposition());
+            info.setContentType(metadata.getContentType());
+            info.setContentMd5(metadata.getContentMD5());
+            info.setLastModified(metadata.getLastModified());
+            if (metadata.getRawMetadata() != null) info.setMetadata(new HashMap<>(metadata.getRawMetadata()));
+            if (metadata.getUserMetadata() != null) info.setUserMetadata(new HashMap<>(metadata.getUserMetadata()));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     /**
      * 获取文件的访问控制列表
      */
@@ -323,24 +422,27 @@ public boolean isSupportPresignedUrl() {
     }
 
     @Override
-    public String generatePresignedUrl(FileInfo fileInfo, Date expiration) {
-        try {
-            return getClient()
-                    .generatePresignedUrl(bucketName, getFileKey(fileInfo), expiration)
-                    .toString();
-        } catch (Exception e) {
-            throw ExceptionFactory.generatePresignedUrl(fileInfo, platform, e);
-        }
-    }
-
-    @Override
-    public String generateThPresignedUrl(FileInfo fileInfo, Date expiration) {
+    public GeneratePresignedUrlResult generatePresignedUrl(GeneratePresignedUrlPretreatment pre) {
         try {
-            String key = getThFileKey(fileInfo);
-            if (key == null) return null;
-            return getClient().generatePresignedUrl(bucketName, key, expiration).toString();
+            String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+            GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, fileKey);
+            request.setExpiration(pre.getExpiration());
+            request.setMethod(Tools.getEnum(HttpMethodName.class, pre.getMethod()));
+            Map<String, String> headers = new HashMap<>(pre.getHeaders());
+            headers.putAll(pre.getUserMetadata().entrySet().stream()
+                    .collect(Collectors.toMap(
+                            e -> e.getKey().startsWith("x-cos-meta-") ? e.getKey() : "x-cos-meta-" + e.getKey(),
+                            Map.Entry::getValue)));
+            headers.forEach(request::putCustomRequestHeader);
+            pre.getQueryParams().forEach(request::addRequestParameter);
+            pre.getResponseHeaders().forEach((k, v) -> request.addRequestParameter("response-" + k.toLowerCase(), v));
+            URL url = getClient().generatePresignedUrl(request);
+            GeneratePresignedUrlResult result = new GeneratePresignedUrlResult(platform, basePath, pre);
+            result.setUrl(url.toString());
+            result.setHeaders(request.getCustomRequestHeaders());
+            return result;
         } catch (Exception e) {
-            throw ExceptionFactory.generateThPresignedUrl(fileInfo, platform, e);
+            throw ExceptionFactory.generatePresignedUrl(pre, e);
         }
     }
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/UpyunUssFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/UpyunUssFileStorage.java
index 4c3b6858..77d699f2 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/UpyunUssFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/UpyunUssFileStorage.java
@@ -1,7 +1,11 @@
 package org.dromara.x.file.storage.core.platform;
 
 import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.date.DatePattern;
+import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.io.file.FileNameUtil;
+import cn.hutool.core.map.MapProxy;
 import cn.hutool.core.util.StrUtil;
 import com.upyun.RestManager;
 import com.upyun.UpException;
@@ -10,11 +14,9 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
+import java.util.*;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
@@ -25,17 +27,19 @@
 import org.dromara.x.file.storage.core.InputStreamPlus;
 import org.dromara.x.file.storage.core.ProgressListener;
 import org.dromara.x.file.storage.core.UploadPretreatment;
+import org.dromara.x.file.storage.core.constant.Constant;
 import org.dromara.x.file.storage.core.copy.CopyPretreatment;
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
 import org.dromara.x.file.storage.core.exception.FileStorageRuntimeException;
 import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.get.*;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
-import org.dromara.x.file.storage.core.upload.CompleteMultipartUploadPretreatment;
-import org.dromara.x.file.storage.core.upload.FilePartInfo;
-import org.dromara.x.file.storage.core.upload.InitiateMultipartUploadPretreatment;
-import org.dromara.x.file.storage.core.upload.UploadPartPretreatment;
+import org.dromara.x.file.storage.core.upload.*;
+import org.dromara.x.file.storage.core.util.KebabCaseInsensitiveMap;
 import org.dromara.x.file.storage.core.util.Tools;
+import org.json.JSONArray;
+import org.json.JSONObject;
 
 /**
  * 又拍云 USS 存储
@@ -236,6 +240,125 @@ public void completeMultipartUpload(CompleteMultipartUploadPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll();
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        RestManager manager = getClient();
+        try {
+            Map<String, String> params = new HashMap<>();
+            if (pre.getMarker() != null) params.put("x-list-iter", pre.getMarker());
+            if (pre.getMaxFiles() != null)
+                params.put("x-list-limit", pre.getMaxFiles().toString());
+            params.put("x-list-order", "asc");
+            params.put("Accept", "application/json");
+            JSONObject result;
+            try (Response response = checkResponse(
+                    manager.readDirIter(basePath + pre.getPath() + pre.getFilenamePrefix(), params), false); ) {
+                if (response.body() == null) {
+                    throw new UpException(response.toString());
+                }
+                result = new JSONObject(response.body().string());
+            }
+
+            ArrayList<RemoteDirInfo> dirList = new ArrayList<>();
+            ArrayList<RemoteFileInfo> fileList = new ArrayList<>();
+            JSONArray files = result.getJSONArray("files");
+            for (int i = 0; i < files.length(); i++) {
+                JSONObject item = files.getJSONObject(0);
+                if ("folder".equals(item.getString("type")) && Long.valueOf(0L).equals(item.getLong("length"))) {
+                    RemoteDirInfo dir = new RemoteDirInfo();
+                    dir.setPlatform(pre.getPlatform());
+                    dir.setBasePath(basePath);
+                    dir.setPath(pre.getPath());
+                    dir.setName(item.getString("name"));
+                    dir.setOriginal(item);
+                    dirList.add(dir);
+                } else {
+                    RemoteFileInfo info = new RemoteFileInfo();
+                    info.setPlatform(pre.getPlatform());
+                    info.setBasePath(basePath);
+                    info.setPath(pre.getPath());
+                    info.setFilename(item.getString("name"));
+                    info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                    info.setSize(item.getLong("length"));
+                    info.setExt(FileNameUtil.extName(info.getFilename()));
+                    info.setETag(item.getString("etag"));
+                    info.setContentType(item.getString("type"));
+                    info.setLastModified(new Date(item.getLong("last_modified") * 1000));
+                    info.setOriginal(item);
+                    fileList.add(info);
+                }
+            }
+            String iter = result.getString("iter");
+            ListFilesResult list = new ListFilesResult();
+            list.setDirList(dirList);
+            list.setFileList(fileList);
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(pre.getMaxFiles());
+            list.setIsTruncated(!"g2gCZAAEbmV4dGQAA2VvZg".equals(iter));
+            list.setMarker(pre.getMarker());
+            list.setNextMarker(list.getIsTruncated() ? iter : null);
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        RestManager client = getClient();
+        try {
+            Response file;
+            try {
+                file = checkResponse(client.getFileInfo(fileKey));
+                Long.parseLong(Objects.requireNonNull(file.header(RestManager.PARAMS.X_UPYUN_FILE_SIZE.getValue())));
+            } catch (Exception e) {
+                return null;
+            }
+
+            KebabCaseInsensitiveMap<String, String> headers =
+                    new KebabCaseInsensitiveMap<>(file.headers().toMultimap().entrySet().stream()
+                            .collect(Collectors.toMap(Map.Entry::getKey, e -> CollUtil.get(e.getValue(), 0))));
+            MapProxy headersProxy = MapProxy.create(headers);
+
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(FileNameUtil.getName(pre.getFilename()));
+            info.setUrl(domain + fileKey);
+            info.setSize(headersProxy.getLong(Constant.Metadata.CONTENT_LENGTH));
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setETag(headersProxy.getStr("etag"));
+            info.setContentDisposition(headersProxy.getStr(Constant.Metadata.CONTENT_DISPOSITION));
+            info.setContentType(headersProxy.getStr(Constant.Metadata.CONTENT_TYPE));
+            info.setContentMd5(headersProxy.getStr(Constant.Metadata.CONTENT_MD5));
+            try {
+                info.setLastModified(DateUtil.parse(
+                        headersProxy.getStr(Constant.Metadata.LAST_MODIFIED), DatePattern.HTTP_DATETIME_FORMAT));
+            } catch (Exception ignored) {
+            }
+            info.setMetadata(headers.entrySet().stream()
+                    .filter(e -> !e.getKey().startsWith("x-upyun-meta-"))
+                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
+            info.setUserMetadata(headers.entrySet().stream()
+                    .filter(e -> e.getKey().startsWith("x-upyun-meta-"))
+                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     /**
      * 获取对象的元数据
      */
@@ -347,6 +470,10 @@ public boolean isSupportSameCopy() {
     }
 
     public Response checkResponse(Response response) throws UpException, IOException {
+        return checkResponse(response, true);
+    }
+
+    public Response checkResponse(Response response, boolean close) throws UpException, IOException {
         if (!response.isSuccessful()) {
             if (response.body() != null) {
                 throw new UpException(response.body().string());
@@ -355,7 +482,7 @@ public Response checkResponse(Response response) throws UpException, IOException
                 throw new UpException(response.toString());
             }
         }
-        response.close();
+        if (close) response.close();
         return response;
     }
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/WebDavFileStorage.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/WebDavFileStorage.java
index b4e53b5d..198e5061 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/WebDavFileStorage.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/WebDavFileStorage.java
@@ -1,12 +1,16 @@
 package org.dromara.x.file.storage.core.platform;
 
+import cn.hutool.core.io.file.FileNameUtil;
 import cn.hutool.core.util.StrUtil;
 import com.github.sardine.DavResource;
 import com.github.sardine.Sardine;
 import com.github.sardine.impl.SardineException;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.Collections;
+import java.util.List;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
@@ -18,6 +22,7 @@
 import org.dromara.x.file.storage.core.copy.CopyPretreatment;
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.exception.ExceptionFactory;
+import org.dromara.x.file.storage.core.get.*;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
 import org.dromara.x.file.storage.core.util.Tools;
 
@@ -116,6 +121,99 @@ public boolean save(FileInfo fileInfo, UploadPretreatment pre) {
         }
     }
 
+    @Override
+    public ListFilesSupportInfo isSupportListFiles() {
+        return ListFilesSupportInfo.supportAll().setSupportMaxFiles(Integer.MAX_VALUE);
+    }
+
+    @Override
+    public ListFilesResult listFiles(ListFilesPretreatment pre) {
+        Sardine client = getClient();
+        try {
+            List<DavResource> result = Collections.emptyList();
+            try {
+                result = client.list(getUrl(basePath + pre.getPath()), 1, false);
+                result.remove(0);
+            } catch (SardineException e) {
+                if (e.getStatusCode() != 404 && e.getStatusCode() != 409) throw e;
+            }
+            ListFilesMatchResult<DavResource> matchResult = listFilesMatch(result, DavResource::getName, pre, false);
+            ListFilesResult list = new ListFilesResult();
+            list.setDirList(matchResult.getList().stream()
+                    .filter(DavResource::isDirectory)
+                    .map(item -> {
+                        RemoteDirInfo dir = new RemoteDirInfo();
+                        dir.setPlatform(pre.getPlatform());
+                        dir.setBasePath(basePath);
+                        dir.setPath(pre.getPath());
+                        dir.setName(item.getName());
+                        dir.setOriginal(item);
+                        return dir;
+                    })
+                    .collect(Collectors.toList()));
+            list.setFileList(matchResult.getList().stream()
+                    .filter(item -> !item.isDirectory())
+                    .map(item -> {
+                        RemoteFileInfo info = new RemoteFileInfo();
+                        info.setPlatform(pre.getPlatform());
+                        info.setBasePath(basePath);
+                        info.setPath(pre.getPath());
+                        info.setFilename(item.getName());
+                        info.setUrl(domain + getFileKey(new FileInfo(basePath, info.getPath(), info.getFilename())));
+                        info.setSize(item.getContentLength());
+                        info.setExt(FileNameUtil.extName(info.getFilename()));
+                        info.setETag(item.getEtag());
+                        info.setContentType(item.getContentType());
+                        info.setLastModified(item.getModified());
+                        info.setOriginal(item);
+                        return info;
+                    })
+                    .collect(Collectors.toList()));
+            list.setPlatform(pre.getPlatform());
+            list.setBasePath(basePath);
+            list.setPath(pre.getPath());
+            list.setFilenamePrefix(pre.getFilenamePrefix());
+            list.setMaxFiles(pre.getMaxFiles());
+            list.setIsTruncated(matchResult.getIsTruncated());
+            list.setMarker(pre.getMarker());
+            list.setNextMarker(matchResult.getNextMarker());
+            return list;
+        } catch (Exception e) {
+            throw ExceptionFactory.listFiles(pre, basePath, e);
+        }
+    }
+
+    @Override
+    public RemoteFileInfo getFile(GetFilePretreatment pre) {
+        String fileKey = getFileKey(new FileInfo(basePath, pre.getPath(), pre.getFilename()));
+        Sardine client = getClient();
+        try {
+            DavResource file;
+            try {
+                String url = getUrl(fileKey);
+                file = client.list(url, 0, false).get(0);
+            } catch (Exception e) {
+                return null;
+            }
+
+            RemoteFileInfo info = new RemoteFileInfo();
+            info.setPlatform(pre.getPlatform());
+            info.setBasePath(basePath);
+            info.setPath(pre.getPath());
+            info.setFilename(file.getName());
+            info.setUrl(domain + fileKey);
+            info.setSize(file.getContentLength());
+            info.setExt(FileNameUtil.extName(info.getFilename()));
+            info.setETag(file.getEtag());
+            info.setContentType(file.getContentType());
+            info.setLastModified(file.getModified());
+            info.setOriginal(file);
+            return info;
+        } catch (Exception e) {
+            throw ExceptionFactory.getFile(pre, basePath, e);
+        }
+    }
+
     @Override
     public boolean delete(FileInfo fileInfo) {
         Sardine client = getClient();
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/presigned/GeneratePresignedUrlActuator.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/presigned/GeneratePresignedUrlActuator.java
new file mode 100644
index 00000000..7289312d
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/presigned/GeneratePresignedUrlActuator.java
@@ -0,0 +1,42 @@
+package org.dromara.x.file.storage.core.presigned;
+
+import java.util.HashMap;
+import java.util.List;
+import org.dromara.x.file.storage.core.FileStorageService;
+import org.dromara.x.file.storage.core.aspect.FileStorageAspect;
+import org.dromara.x.file.storage.core.aspect.GeneratePresignedUrlAspectChain;
+import org.dromara.x.file.storage.core.exception.Check;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 生成预签名 URL 执行器
+ */
+public class GeneratePresignedUrlActuator {
+    private final FileStorageService fileStorageService;
+    private final GeneratePresignedUrlPretreatment pre;
+
+    public GeneratePresignedUrlActuator(GeneratePresignedUrlPretreatment pre) {
+        this.pre = pre;
+        this.fileStorageService = pre.getFileStorageService();
+    }
+
+    /**
+     * 执行生成预签名 URL
+     */
+    public GeneratePresignedUrlResult execute() {
+        return execute(fileStorageService.getFileStorageVerify(pre.getPlatform()), fileStorageService.getAspectList());
+    }
+
+    /**
+     * 执行生成预签名 URL
+     */
+    public GeneratePresignedUrlResult execute(FileStorage fileStorage, List<FileStorageAspect> aspectList) {
+        Check.generatePresignedUrl(pre);
+        return new GeneratePresignedUrlAspectChain(aspectList, (_pre, _fileStorage) -> {
+                    GeneratePresignedUrlResult result = _fileStorage.generatePresignedUrl(_pre);
+                    if (result.getHeaders() == null) result.setHeaders(new HashMap<>());
+                    return result;
+                })
+                .next(pre, fileStorage);
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/presigned/GeneratePresignedUrlPretreatment.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/presigned/GeneratePresignedUrlPretreatment.java
new file mode 100644
index 00000000..442c7c45
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/presigned/GeneratePresignedUrlPretreatment.java
@@ -0,0 +1,304 @@
+package org.dromara.x.file.storage.core.presigned;
+
+import java.util.Date;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.Accessors;
+import org.dromara.x.file.storage.core.FileStorageService;
+import org.dromara.x.file.storage.core.aspect.FileStorageAspect;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+
+/**
+ * 生成预签名 URL 预处理器
+ */
+@Getter
+@Setter
+@Accessors(chain = true)
+public class GeneratePresignedUrlPretreatment {
+    /**
+     * 文件存储服务类
+     */
+    private FileStorageService fileStorageService;
+    /**
+     * 存储平台名称
+     */
+    private String platform;
+    /**
+     * 路径
+     */
+    private String path = "";
+    /**
+     * 文件名
+     */
+    private String filename = "";
+    /**
+     * 生效开始时间，仅 Azure Blob Storage 存储平台支持
+     */
+    private Date startTime;
+    /**
+     * 到期时间
+     */
+    private Date expiration;
+    /**
+     * HTTP 请求方法，可以直接传入字符串或对应存储平台支持的类型
+     * {@link org.dromara.x.file.storage.core.constant.Constant.GeneratePresignedUrl.Method}
+     */
+    private Object method;
+    /**
+     * 特殊操作符，可以直接传入字符串或对应存储平台支持的类型，仅华为云存储平台支持
+     */
+    private Object specialParam;
+    /**
+     * 请求头（元数据）
+     */
+    private Map<String, String> headers;
+    /**
+     * 用户元数据
+     */
+    private Map<String, String> userMetadata;
+    /**
+     * 查询参数
+     */
+    private Map<String, String> queryParams;
+    /**
+     * 要在服务响应中重写的标头，实际效果以每个存储平台支持为准
+     */
+    private Map<String, String> responseHeaders;
+
+    /**
+     * 如果条件为 true 则：设置文件存储服务类
+     * @param flag 条件
+     * @param fileStorageService 文件存储服务类
+     * @return 获取文件预处理器
+     */
+    public GeneratePresignedUrlPretreatment setFileStorageService(boolean flag, FileStorageService fileStorageService) {
+        if (flag) setFileStorageService(fileStorageService);
+        return this;
+    }
+
+    /**
+     * 设置存储平台名称（如果条件为 true）
+     * @param flag 条件
+     * @param platform 存储平台名称
+     * @return 获取文件预处理器
+     */
+    public GeneratePresignedUrlPretreatment setPlatform(boolean flag, String platform) {
+        if (flag) setPlatform(platform);
+        return this;
+    }
+
+    /**
+     * 设置路径，需要与上传时传入的路径保持一致（如果条件为 true）
+     * @param flag 条件
+     * @param path 文件访问地址
+     * @return 获取文件预处理器
+     */
+    public GeneratePresignedUrlPretreatment setPath(boolean flag, String path) {
+        if (flag) setPath(path);
+        return this;
+    }
+
+    /**
+     * 设置到期时间（如果条件为 true）
+     * @param flag 条件
+     * @param expiration 到期时间
+     * @return 获取文件预处理器
+     */
+    public GeneratePresignedUrlPretreatment setExpiration(boolean flag, Date expiration) {
+        if (flag) setExpiration(expiration);
+        return this;
+    }
+
+    /**
+     * 获取请求头（元数据）
+     */
+    public Map<String, String> getHeaders() {
+        if (headers == null) headers = new LinkedHashMap<>();
+        return headers;
+    }
+
+    /**
+     * 设置请求头（元数据）
+     */
+    public GeneratePresignedUrlPretreatment putHeaders(boolean flag, String key, String value) {
+        if (flag) putHeaders(key, value);
+        return this;
+    }
+
+    /**
+     * 设置请求头（元数据）
+     */
+    public GeneratePresignedUrlPretreatment putHeaders(String key, String value) {
+        getHeaders().put(key, value);
+        return this;
+    }
+
+    /**
+     * 设置请求头（元数据）
+     */
+    public GeneratePresignedUrlPretreatment putHeadersAll(boolean flag, Map<String, String> headers) {
+        if (flag) putHeadersAll(headers);
+        return this;
+    }
+
+    /**
+     * 设置请求头（元数据）
+     */
+    public GeneratePresignedUrlPretreatment putHeadersAll(Map<String, String> headers) {
+        getHeaders().putAll(headers);
+        return this;
+    }
+
+    /**
+     * 获取文件用户元数据
+     */
+    public Map<String, String> getUserMetadata() {
+        if (userMetadata == null) userMetadata = new LinkedHashMap<>();
+        return userMetadata;
+    }
+
+    /**
+     * 设置文件用户元数据
+     */
+    public GeneratePresignedUrlPretreatment putUserMetadata(boolean flag, String key, String value) {
+        if (flag) putUserMetadata(key, value);
+        return this;
+    }
+
+    /**
+     * 设置文件用户元数据
+     */
+    public GeneratePresignedUrlPretreatment putUserMetadata(String key, String value) {
+        getUserMetadata().put(key, value);
+        return this;
+    }
+
+    /**
+     * 设置文件用户元数据
+     */
+    public GeneratePresignedUrlPretreatment putUserMetadataAll(boolean flag, Map<String, String> userMetadata) {
+        if (flag) putUserMetadataAll(userMetadata);
+        return this;
+    }
+
+    /**
+     * 设置文件用户元数据
+     */
+    public GeneratePresignedUrlPretreatment putUserMetadataAll(Map<String, String> userMetadata) {
+        getUserMetadata().putAll(userMetadata);
+        return this;
+    }
+
+    /**
+     * 获取查询参数
+     */
+    public Map<String, String> getQueryParams() {
+        if (queryParams == null) queryParams = new LinkedHashMap<>();
+        return queryParams;
+    }
+
+    /**
+     * 设置查询参数
+     */
+    public GeneratePresignedUrlPretreatment putQueryParams(boolean flag, String key, String value) {
+        if (flag) putQueryParams(key, value);
+        return this;
+    }
+
+    /**
+     * 设置查询参数
+     */
+    public GeneratePresignedUrlPretreatment putQueryParams(String key, String value) {
+        getQueryParams().put(key, value);
+        return this;
+    }
+
+    /**
+     * 设置查询参数
+     */
+    public GeneratePresignedUrlPretreatment putQueryParamsAll(boolean flag, Map<String, String> queryParams) {
+        if (flag) putQueryParamsAll(queryParams);
+        return this;
+    }
+
+    /**
+     * 设置查询参数
+     */
+    public GeneratePresignedUrlPretreatment putQueryParamsAll(Map<String, String> queryParams) {
+        getQueryParams().putAll(queryParams);
+        return this;
+    }
+
+    /**
+     * 设置要在服务响应中重写的标头，实际效果以每个存储平台支持为准
+     */
+    public Map<String, String> getResponseHeaders() {
+        if (responseHeaders == null) responseHeaders = new LinkedHashMap<>();
+        return responseHeaders;
+    }
+
+    /**
+     * 设置要在服务响应中重写的标头，实际效果以每个存储平台支持为准
+     */
+    public GeneratePresignedUrlPretreatment putResponseHeaders(boolean flag, String key, String value) {
+        if (flag) putResponseHeaders(key, value);
+        return this;
+    }
+
+    /**
+     * 设置要在服务响应中重写的标头，实际效果以每个存储平台支持为准
+     */
+    public GeneratePresignedUrlPretreatment putResponseHeaders(String key, String value) {
+        getResponseHeaders().put(key, value);
+        return this;
+    }
+
+    /**
+     * 设置要在服务响应中重写的标头，实际效果以每个存储平台支持为准
+     */
+    public GeneratePresignedUrlPretreatment putResponseHeadersAll(boolean flag, Map<String, String> responseHeader) {
+        if (flag) putResponseHeadersAll(responseHeader);
+        return this;
+    }
+
+    /**
+     * 设置要在服务响应中重写的标头，实际效果以每个存储平台支持为准
+     */
+    public GeneratePresignedUrlPretreatment putResponseHeadersAll(Map<String, String> responseHeader) {
+        getResponseHeaders().putAll(responseHeader);
+        return this;
+    }
+
+    /**
+     * 设置文件版本 ID
+     */
+    public GeneratePresignedUrlPretreatment setVersionId(String versionId) {
+        return putQueryParams("versionId", versionId);
+    }
+
+    /**
+     * 设置文件版本 ID
+     */
+    public GeneratePresignedUrlPretreatment setVersionId(boolean flag, String versionId) {
+        if (flag) putQueryParams("versionId", versionId);
+        return this;
+    }
+
+    /**
+     * 执行生成预签名 URL
+     */
+    public GeneratePresignedUrlResult generatePresignedUrl() {
+        return new GeneratePresignedUrlActuator(this).execute();
+    }
+
+    /**
+     * 执行生成预签名 URL，此方法仅限内部使用
+     */
+    public GeneratePresignedUrlResult generatePresignedUrl(
+            FileStorage fileStorage, List<FileStorageAspect> aspectList) {
+        return new GeneratePresignedUrlActuator(this).execute(fileStorage, aspectList);
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/presigned/GeneratePresignedUrlResult.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/presigned/GeneratePresignedUrlResult.java
new file mode 100644
index 00000000..7da36091
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/presigned/GeneratePresignedUrlResult.java
@@ -0,0 +1,46 @@
+package org.dromara.x.file.storage.core.presigned;
+
+import java.util.Map;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+/**
+ * 生成预签名 URL 结果
+ */
+@Data
+@NoArgsConstructor
+@Accessors(chain = true)
+public class GeneratePresignedUrlResult {
+    /**
+     * 存储平台
+     */
+    private String platform;
+    /**
+     * 基础存储路径
+     */
+    private String basePath;
+    /**
+     * 存储路径
+     */
+    private String path;
+    /**
+     * 文件名称
+     */
+    private String filename;
+    /**
+     * URL
+     */
+    private String url;
+    /**
+     * 访问 URL 时需要附带的请求头
+     */
+    private Map<String, String> headers;
+
+    public GeneratePresignedUrlResult(String platform, String basePath, GeneratePresignedUrlPretreatment pre) {
+        this.platform = platform;
+        this.basePath = basePath;
+        this.path = pre.getPath();
+        this.filename = pre.getFilename();
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/recorder/DefaultFileRecorder.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/recorder/DefaultFileRecorder.java
index 2e899ca7..6ef5ff2c 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/recorder/DefaultFileRecorder.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/recorder/DefaultFileRecorder.java
@@ -18,7 +18,7 @@ public void update(FileInfo fileInfo) {}
     @Override
     public FileInfo getByUrl(String url) {
         throw new FileStorageRuntimeException(
-                "尚未实现 FileRecorder 接口，暂时无法使用此功能，可以参考文档快速入门的其它操作章节，或者参考保存上传记录章节：https://x-file-storage.xuyanwu.cn/2.1.0/#/%E5%9F%BA%E7%A1%80%E5%8A%9F%E8%83%BD?id=%E4%BF%9D%E5%AD%98%E4%B8%8A%E4%BC%A0%E8%AE%B0%E5%BD%95");
+                "尚未实现 FileRecorder 接口，暂时无法使用此功能，可以参考文档快速入门的其它操作章节，或者参考保存上传记录章节：https://x-file-storage.xuyanwu.cn/2.2.0/#/%E5%9F%BA%E7%A1%80%E5%8A%9F%E8%83%BD?id=%E4%BF%9D%E5%AD%98%E4%B8%8A%E4%BC%A0%E8%AE%B0%E5%BD%95");
     }
 
     @Override
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/recorder/FileRecorder.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/recorder/FileRecorder.java
index 4756c8f6..1a5417c9 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/recorder/FileRecorder.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/recorder/FileRecorder.java
@@ -4,7 +4,7 @@
 import org.dromara.x.file.storage.core.upload.FilePartInfo;
 
 /**
- * 文件记录记录者接口，参考文档：https://x-file-storage.xuyanwu.cn/2.1.0/#/%E5%9F%BA%E7%A1%80%E5%8A%9F%E8%83%BD?id=%E4%BF%9D%E5%AD%98%E4%B8%8A%E4%BC%A0%E8%AE%B0%E5%BD%95
+ * 文件记录记录者接口，参考文档：https://x-file-storage.xuyanwu.cn/2.2.0/#/%E5%9F%BA%E7%A1%80%E5%8A%9F%E8%83%BD?id=%E4%BF%9D%E5%AD%98%E4%B8%8A%E4%BC%A0%E8%AE%B0%E5%BD%95
  */
 public interface FileRecorder {
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/AbortMultipartUploadPretreatment.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/AbortMultipartUploadPretreatment.java
index 055d5bc8..16a50e15 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/AbortMultipartUploadPretreatment.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/AbortMultipartUploadPretreatment.java
@@ -22,6 +22,28 @@ public class AbortMultipartUploadPretreatment {
      */
     private FileInfo fileInfo;
 
+    /**
+     * 如果条件为 true 则：设置文件存储服务类
+     * @param flag 条件
+     * @param fileStorageService 文件存储服务类
+     * @return 手动分片上传-取消预处理器
+     */
+    public AbortMultipartUploadPretreatment setFileStorageService(boolean flag, FileStorageService fileStorageService) {
+        if (flag) setFileStorageService(fileStorageService);
+        return this;
+    }
+
+    /**
+     * 如果条件为 true 则：设置文件信息
+     * @param flag 条件
+     * @param fileInfo 文件信息
+     * @return 手动分片上传-取消预处理器
+     */
+    public AbortMultipartUploadPretreatment setFileInfo(boolean flag, FileInfo fileInfo) {
+        if (flag) setFileInfo(fileInfo);
+        return this;
+    }
+
     /**
      * 执行取消
      */
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/CompleteMultipartUploadActuator.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/CompleteMultipartUploadActuator.java
index c0170b3b..dfbec90f 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/CompleteMultipartUploadActuator.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/CompleteMultipartUploadActuator.java
@@ -12,7 +12,6 @@
 import org.dromara.x.file.storage.core.constant.Constant;
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.platform.FileStorage;
-import org.dromara.x.file.storage.core.platform.MultipartUploadSupportInfo;
 import org.dromara.x.file.storage.core.recorder.FileRecorder;
 import org.dromara.x.file.storage.core.tika.ContentTypeDetect;
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/CompleteMultipartUploadPretreatment.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/CompleteMultipartUploadPretreatment.java
index 04e47a8c..1b90e5d9 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/CompleteMultipartUploadPretreatment.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/CompleteMultipartUploadPretreatment.java
@@ -34,6 +34,40 @@ public class CompleteMultipartUploadPretreatment
      */
     private ProgressListener progressListener;
 
+    /**
+     * 如果条件为 true 则：设置文件存储服务类
+     * @param flag 条件
+     * @param fileStorageService 文件存储服务类
+     * @return 手动分片上传-完成预处理器
+     */
+    public CompleteMultipartUploadPretreatment setFileStorageService(
+            boolean flag, FileStorageService fileStorageService) {
+        if (flag) setFileStorageService(fileStorageService);
+        return this;
+    }
+
+    /**
+     * 如果条件为 true 则：设置文件信息
+     * @param flag 条件
+     * @param fileInfo 文件信息
+     * @return 手动分片上传-完成预处理器
+     */
+    public CompleteMultipartUploadPretreatment setFileInfo(boolean flag, FileInfo fileInfo) {
+        if (flag) setFileInfo(fileInfo);
+        return this;
+    }
+
+    /**
+     * 如果条件为 true 则：设置文件分片信息，不传则自动使用全部已上传的分片
+     * @param flag 条件
+     * @param partInfoList 文件分片信息，不传则自动使用全部已上传的分片
+     * @return 手动分片上传-完成预处理器
+     */
+    public CompleteMultipartUploadPretreatment setFileInfo(boolean flag, List<FilePartInfo> partInfoList) {
+        if (flag) setPartInfoList(partInfoList);
+        return this;
+    }
+
     /**
      * 执行完成
      */
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/ListPartsActuator.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/ListPartsActuator.java
index 5504b65e..87a5c744 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/ListPartsActuator.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/ListPartsActuator.java
@@ -7,7 +7,6 @@
 import org.dromara.x.file.storage.core.aspect.ListPartsAspectChain;
 import org.dromara.x.file.storage.core.exception.Check;
 import org.dromara.x.file.storage.core.platform.FileStorage;
-import org.dromara.x.file.storage.core.platform.MultipartUploadSupportInfo;
 
 /**
  * 手动分片上传-列举已上传的分片执行器
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/ListPartsPretreatment.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/ListPartsPretreatment.java
index 0d2e25e5..6505fa0e 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/ListPartsPretreatment.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/ListPartsPretreatment.java
@@ -35,6 +35,50 @@ public class ListPartsPretreatment {
      */
     private Integer partNumberMarker = 0;
 
+    /**
+     * 如果条件为 true 则：设置文件存储服务类
+     * @param flag 条件
+     * @param fileStorageService 文件存储服务类
+     * @return 手动分片上传-列举已上传的分片预处理器
+     */
+    public ListPartsPretreatment setFileStorageService(boolean flag, FileStorageService fileStorageService) {
+        if (flag) setFileStorageService(fileStorageService);
+        return this;
+    }
+
+    /**
+     * 如果条件为 true 则：设置文件信息
+     * @param flag 条件
+     * @param fileInfo 文件信息
+     * @return 手动分片上传-列举已上传的分片预处理器
+     */
+    public ListPartsPretreatment setFileInfo(boolean flag, FileInfo fileInfo) {
+        if (flag) setFileInfo(fileInfo);
+        return this;
+    }
+
+    /**
+     * 如果条件为 true 则：设置要列出的最大分片数量，正常情况下分片范围为 0~10000，这里默认最大值表示全部分片
+     * @param flag 条件
+     * @param maxParts 要列出的最大分片数量，正常情况下分片范围为 0~10000，这里默认最大值表示全部分片
+     * @return 手动分片上传-列举已上传的分片预处理器
+     */
+    public ListPartsPretreatment setMaxParts(boolean flag, Integer maxParts) {
+        if (flag) setMaxParts(maxParts);
+        return this;
+    }
+
+    /**
+     * 如果条件为 true 则：设置表示待列出分片的起始位置，只有分片号（partNumber）大于该参数的分片会被列出，默认从头开始
+     * @param flag 条件
+     * @param partNumberMarker 表示待列出分片的起始位置，只有分片号（partNumber）大于该参数的分片会被列出，默认从头开始
+     * @return 手动分片上传-列举已上传的分片预处理器
+     */
+    public ListPartsPretreatment setPartNumberMarker(boolean flag, Integer partNumberMarker) {
+        if (flag) setPartNumberMarker(partNumberMarker);
+        return this;
+    }
+
     /**
      * 执行列举已上传的分片
      */
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/MultipartUploadSupportInfo.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/MultipartUploadSupportInfo.java
similarity index 92%
rename from x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/MultipartUploadSupportInfo.java
rename to x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/MultipartUploadSupportInfo.java
index 5c674914..e6198fd2 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/platform/MultipartUploadSupportInfo.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/MultipartUploadSupportInfo.java
@@ -1,4 +1,4 @@
-package org.dromara.x.file.storage.core.platform;
+package org.dromara.x.file.storage.core.upload;
 
 import lombok.AllArgsConstructor;
 import lombok.Data;
@@ -20,7 +20,7 @@ public class MultipartUploadSupportInfo {
 
     /**
      * 是否支持列举已上传的分片，又拍云 USS 不支持，建议将上传完成的分片信息通过 FileRecorder 接口保存到数据库，
-     * 详情：https://x-file-storage.xuyanwu.cn/2.1.0/#/%E5%9F%BA%E7%A1%80%E5%8A%9F%E8%83%BD?id=%E4%BF%9D%E5%AD%98%E4%B8%8A%E4%BC%A0%E8%AE%B0%E5%BD%95
+     * 详情：https://x-file-storage.xuyanwu.cn/2.2.0/#/%E5%9F%BA%E7%A1%80%E5%8A%9F%E8%83%BD?id=%E4%BF%9D%E5%AD%98%E4%B8%8A%E4%BC%A0%E8%AE%B0%E5%BD%95
      */
     private Boolean isSupportListParts;
 
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/UploadPartPretreatment.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/UploadPartPretreatment.java
index 74ac0c88..831f08ff 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/UploadPartPretreatment.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/UploadPartPretreatment.java
@@ -48,6 +48,50 @@ public class UploadPartPretreatment
      */
     private InputStreamPlus inputStreamPlus;
 
+    /**
+     * 如果条件为 true 则：设置文件存储服务类
+     * @param flag 条件
+     * @param fileStorageService 文件存储服务类
+     * @return 手动分片上传-上传分片预处理器
+     */
+    public UploadPartPretreatment setFileStorageService(boolean flag, FileStorageService fileStorageService) {
+        if (flag) setFileStorageService(fileStorageService);
+        return this;
+    }
+
+    /**
+     * 如果条件为 true 则：设置文件信息
+     * @param flag 条件
+     * @param fileInfo 文件信息
+     * @return 手动分片上传-上传分片预处理器
+     */
+    public UploadPartPretreatment setFileInfo(boolean flag, FileInfo fileInfo) {
+        if (flag) setFileInfo(fileInfo);
+        return this;
+    }
+
+    /**
+     * 如果条件为 true 则：设置要上传的分片文件包装类
+     * @param flag 条件
+     * @param partFileWrapper 要上传的分片文件包装类
+     * @return 手动分片上传-上传分片预处理器
+     */
+    public UploadPartPretreatment setPartFileWrapper(boolean flag, FileWrapper partFileWrapper) {
+        if (flag) setPartFileWrapper(partFileWrapper);
+        return this;
+    }
+
+    /**
+     * 如果条件为 true 则：设置分片号。每一个上传的分片都有一个分片号，一般情况下取值范围是1~10000
+     * @param flag 条件
+     * @param partNumber 分片号。每一个上传的分片都有一个分片号，一般情况下取值范围是1~10000
+     * @return 手动分片上传-上传分片预处理器
+     */
+    public UploadPartPretreatment setPartNumber(boolean flag, int partNumber) {
+        if (flag) setPartNumber(partNumber);
+        return this;
+    }
+
     /**
      * 添加一个哈希计算器
      * @param hashCalculator 哈希计算器
@@ -81,7 +125,10 @@ public InputStreamPlus getInputStreamPlus() throws IOException {
     public InputStreamPlus getInputStreamPlus(boolean hasListener) throws IOException {
         if (inputStreamPlus == null) {
             inputStreamPlus = new InputStreamPlus(
-                    partFileWrapper.getInputStream(), hasListener ? progressListener : null, partFileWrapper.getSize());
+                    partFileWrapper.getInputStream(),
+                    hasListener ? progressListener : null,
+                    partFileWrapper.getSize(),
+                    hashCalculatorManager);
         }
         return inputStreamPlus;
     }
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/UploadPretreatment.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/UploadPretreatment.java
index e6ef11c5..2634aecf 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/UploadPretreatment.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/upload/UploadPretreatment.java
@@ -39,6 +39,7 @@ public UploadPretreatment(org.dromara.x.file.storage.core.UploadPretreatment pre
         setFileWrapper(pre.getFileWrapper());
         setThumbnailBytes(pre.getThumbnailBytes());
         setThumbnailSuffix(pre.getThumbnailSuffix());
+        setIgnoreThumbnailException(pre.isIgnoreThumbnailException());
         setObjectId(pre.getObjectId());
         setObjectType(pre.getObjectType());
         setPath(pre.getPath());
@@ -206,6 +207,13 @@ public UploadPretreatment setThumbnailSuffix(String thumbnailSuffix) {
         return (UploadPretreatment) super.setThumbnailSuffix(thumbnailSuffix);
     }
 
+    /**
+     * 忽略生成缩略图时的错误，需要在生成缩略图之前设置
+     */
+    public UploadPretreatment setIgnoreThumbnailException(boolean flag, boolean ignoreThumbnailException) {
+        return (UploadPretreatment) super.setIgnoreThumbnailException(flag, ignoreThumbnailException);
+    }
+
     /**
      * 文件所属对象类型
      */
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/util/KebabCaseInsensitiveMap.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/util/KebabCaseInsensitiveMap.java
new file mode 100644
index 00000000..3b42df86
--- /dev/null
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/util/KebabCaseInsensitiveMap.java
@@ -0,0 +1,87 @@
+package org.dromara.x.file.storage.core.util;
+
+import cn.hutool.core.map.FuncKeyMap;
+import cn.hutool.core.map.MapBuilder;
+import cn.hutool.core.text.NamingCase;
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+/**
+ * 短横Key风格且不区分大小写的Map<br>
+ * 对KEY转换为短横，以下方式都获得的值相同，put进入的值也会被覆盖<br>
+ * get("ContentType")<br>
+ * get("Content_Type")<br>
+ * get("HelloWorld_test")<br>
+ * get("Content-Type")<br>
+ * get("contentType")<br>
+ *
+ * @param <K> 键类型
+ * @param <V> 值类型
+ */
+public class KebabCaseInsensitiveMap<K, V> extends FuncKeyMap<K, V> {
+    private static final long serialVersionUID = 4043263744224569870L;
+
+    /**
+     * 构造
+     */
+    public KebabCaseInsensitiveMap() {
+        this(DEFAULT_INITIAL_CAPACITY);
+    }
+
+    /**
+     * 构造
+     *
+     * @param initialCapacity 初始大小
+     */
+    public KebabCaseInsensitiveMap(int initialCapacity) {
+        this(initialCapacity, DEFAULT_LOAD_FACTOR);
+    }
+
+    /**
+     * 构造
+     *
+     * @param m Map
+     */
+    public KebabCaseInsensitiveMap(Map<? extends K, ? extends V> m) {
+        this(DEFAULT_LOAD_FACTOR, m);
+    }
+
+    /**
+     * 构造
+     *
+     * @param loadFactor 加载因子
+     * @param m          初始Map，数据会被默认拷贝到一个新的HashMap中
+     */
+    public KebabCaseInsensitiveMap(float loadFactor, Map<? extends K, ? extends V> m) {
+        this(m.size(), loadFactor);
+        this.putAll(m);
+    }
+
+    /**
+     * 构造
+     *
+     * @param initialCapacity 初始大小
+     * @param loadFactor      加载因子
+     */
+    public KebabCaseInsensitiveMap(int initialCapacity, float loadFactor) {
+        this(MapBuilder.create(new HashMap<>(initialCapacity, loadFactor)));
+    }
+
+    /**
+     * 构造<br>
+     * 注意此构造将传入的Map作为被包装的Map，针对任何修改，传入的Map都会被同样修改。
+     *
+     * @param emptyMapBuilder Map构造器，必须构造空的Map
+     */
+    KebabCaseInsensitiveMap(MapBuilder<K, V> emptyMapBuilder) {
+        super(emptyMapBuilder.build(), (Function<Object, K> & Serializable) (key) -> {
+            if (key instanceof CharSequence) {
+                key = NamingCase.toKebabCase(NamingCase.toCamelCase(key.toString()))
+                        .toLowerCase();
+            }
+            return Tools.cast(key);
+        });
+    }
+}
diff --git a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/util/Tools.java b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/util/Tools.java
index 2937dc59..36fc3cdb 100644
--- a/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/util/Tools.java
+++ b/x-file-storage-core/src/main/java/org/dromara/x/file/storage/core/util/Tools.java
@@ -1,7 +1,12 @@
 package org.dromara.x.file.storage.core.util;
 
+import cn.hutool.core.map.CaseInsensitiveMap;
+import cn.hutool.core.util.EnumUtil;
+import cn.hutool.core.util.StrUtil;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 public class Tools {
     /**
@@ -61,4 +66,25 @@ public static <T> T getNotNull(T... args) {
         for (T t : args) if (t != null) return t;
         throw new NullPointerException();
     }
+
+    /**
+     * 将 Map 的 key 和 value 转换成 String 类型
+     */
+    public static <K, V> Map<String, String> toStringMap(Map<? extends K, ? extends V> map) {
+        if (map == null) return null;
+        return map.entrySet().stream()
+                .collect(Collectors.toMap(
+                        e -> StrUtil.toStringOrNull(e.getKey()), e -> StrUtil.toStringOrNull(e.getValue())));
+    }
+
+    /**
+     * 获取枚举类型（忽略大小写）
+     */
+    public static <E extends Enum<E>> E getEnum(Class<E> enumClass, Object value) {
+        if (value == null) return null;
+        if (enumClass.isInstance(value)) {
+            return Tools.cast(value);
+        }
+        return new CaseInsensitiveMap<>(EnumUtil.getEnumMap(enumClass)).get(value.toString());
+    }
 }
diff --git a/x-file-storage-solon/pom.xml b/x-file-storage-solon/pom.xml
new file mode 100644
index 00000000..011935bf
--- /dev/null
+++ b/x-file-storage-solon/pom.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>org.dromara.x-file-storage</groupId>
+        <artifactId>x-file-storage-parent</artifactId>
+        <version>${revision}</version>
+    </parent>
+
+    <artifactId>x-file-storage-solon</artifactId>
+    <name>X File Storage Solon</name>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.dromara.x-file-storage</groupId>
+            <artifactId>x-file-storage-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <scope>provided</scope>
+            <optional>true</optional>
+        </dependency>
+
+        <dependency>
+            <groupId>org.noear</groupId>
+            <artifactId>solon</artifactId>
+            <version>${solon.version}</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.noear</groupId>
+            <artifactId>solon.web.staticfiles</artifactId>
+            <version>${solon.version}</version>
+            <scope>provided</scope>
+        </dependency>
+
+    </dependencies>
+
+</project>
diff --git a/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/DromaraXFileStoragePluginImpl.java b/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/DromaraXFileStoragePluginImpl.java
new file mode 100644
index 00000000..cbb0f7e6
--- /dev/null
+++ b/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/DromaraXFileStoragePluginImpl.java
@@ -0,0 +1,68 @@
+package org.dromara.x.file.storage.solon;
+
+import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+import org.noear.solon.core.AppContext;
+import org.noear.solon.core.Plugin;
+import org.noear.solon.web.staticfiles.StaticMappings;
+import org.noear.solon.web.staticfiles.repository.FileStaticRepository;
+
+/**
+ * 启动时 注册本地存储的访问地址
+ * @author link2fun
+ */
+@Slf4j
+public class DromaraXFileStoragePluginImpl implements Plugin {
+    /**
+     * 启动（保留，为兼容性过度）
+     *
+     * @param context 应用上下文
+     */
+    @Override
+    public void start(final AppContext context) {
+
+        // 配置包扫描, 扫描当前插件包下的所有类
+        context.beanScan(FileStorageAutoConfiguration.class);
+
+        // 通过插件 配置本地存储的访问地址
+        context.getBeanAsync(SolonFileStorageProperties.class, cfg -> {
+
+            // local 配置
+            //noinspection deprecation
+            final List<? extends SolonFileStorageProperties.SpringLocalConfig> localList = cfg.getLocal();
+            //noinspection deprecation
+            for (final SolonFileStorageProperties.SpringLocalConfig localConfig : localList) {
+
+                if (!localConfig.getEnableStorage() || !localConfig.getEnableAccess()) {
+                    // 没有启用存储或 不允许访问, 则不配置映射
+                    continue;
+                }
+
+                // 添加本地绝对目录（例：/img/logo.jpg 映射地址为：/data/sss/app/img/logo.jpg）
+                StaticMappings.add(localConfig.getPathPatterns(), new FileStaticRepository(localConfig.getBasePath()));
+                log.info(
+                        "[x-file-storage] [local] 添加本地存储映射: {} -> {}",
+                        localConfig.getPathPatterns(),
+                        localConfig.getBasePath());
+            }
+
+            // localPlus 配置
+            final List<? extends SolonFileStorageProperties.SpringLocalPlusConfig> localPlusList = cfg.getLocalPlus();
+            for (final SolonFileStorageProperties.SpringLocalPlusConfig localPlusConfig : localPlusList) {
+
+                if (!localPlusConfig.getEnableStorage() || !localPlusConfig.getEnableAccess()) {
+                    // 没有启用存储或 不允许访问, 则不配置映射
+                    continue;
+                }
+
+                // 添加本地绝对目录（例：/img/logo.jpg 映射地址为：/data/sss/app/img/logo.jpg）
+                StaticMappings.add(
+                        localPlusConfig.getPathPatterns(), new FileStaticRepository(localPlusConfig.getStoragePath()));
+                log.info(
+                        "[x-file-storage] [localPlus] 添加本地存储映射: {} -> {}",
+                        localPlusConfig.getPathPatterns(),
+                        localPlusConfig.getStoragePath());
+            }
+        });
+    }
+}
diff --git a/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/FileStorageAutoConfiguration.java b/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/FileStorageAutoConfiguration.java
new file mode 100644
index 00000000..17cec32e
--- /dev/null
+++ b/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/FileStorageAutoConfiguration.java
@@ -0,0 +1,168 @@
+package org.dromara.x.file.storage.solon;
+
+import static org.dromara.x.file.storage.core.FileStorageServiceBuilder.doesNotExistClass;
+
+import java.util.ArrayList;
+import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+import org.dromara.x.file.storage.core.FileStorageService;
+import org.dromara.x.file.storage.core.FileStorageServiceBuilder;
+import org.dromara.x.file.storage.core.aspect.FileStorageAspect;
+import org.dromara.x.file.storage.core.file.FileWrapperAdapter;
+import org.dromara.x.file.storage.core.platform.FileStorage;
+import org.dromara.x.file.storage.core.platform.FileStorageClientFactory;
+import org.dromara.x.file.storage.core.recorder.DefaultFileRecorder;
+import org.dromara.x.file.storage.core.recorder.FileRecorder;
+import org.dromara.x.file.storage.core.tika.ContentTypeDetect;
+import org.dromara.x.file.storage.core.tika.DefaultTikaFactory;
+import org.dromara.x.file.storage.core.tika.TikaContentTypeDetect;
+import org.dromara.x.file.storage.core.tika.TikaFactory;
+import org.dromara.x.file.storage.solon.SolonFileStorageProperties.SpringLocalConfig;
+import org.dromara.x.file.storage.solon.SolonFileStorageProperties.SpringLocalPlusConfig;
+import org.dromara.x.file.storage.solon.file.UploadedFileWrapperAdapter;
+import org.noear.solon.Solon;
+import org.noear.solon.annotation.*;
+
+/**
+ * @author link2fun
+ */
+@Slf4j
+@Configuration
+@Condition(onMissingBean = FileStorageService.class)
+public class FileStorageAutoConfiguration {
+
+    @Inject
+    private SolonFileStorageProperties properties;
+
+    @Bean
+    public SolonFileStorageProperties solonFileStorageProperties(
+            @Inject("${dromara.x-file-storage}") SolonFileStorageProperties properties) {
+        return properties;
+    }
+
+    /**
+     * 当没有找到 FileRecorder 时使用默认的 FileRecorder
+     */
+    @Bean
+    @Condition(onMissingBean = FileRecorder.class)
+    public FileRecorder fileRecorder() {
+        log.warn("没有找到 FileRecorder 的实现类，文件上传之外的部分功能无法正常使用，必须实现该接口才能使用完整功能！");
+        return new DefaultFileRecorder();
+    }
+
+    /**
+     * Tika 工厂类型，用于识别上传的文件的 MINE
+     */
+    @Bean
+    @Condition(onMissingBean = TikaFactory.class)
+    public TikaFactory tikaFactory() {
+        return new DefaultTikaFactory();
+    }
+
+    /**
+     * 识别文件的 MIME 类型
+     */
+    @Bean
+    @Condition(onMissingBean = ContentTypeDetect.class)
+    public ContentTypeDetect contentTypeDetect(TikaFactory tikaFactory) {
+        return new TikaContentTypeDetect(tikaFactory);
+    }
+
+    /**
+     * 文件存储服务
+     */
+    //  @Bean(destroyMethod = "destroy")
+    @Bean
+    public FileStorageService fileStorageService(
+            FileRecorder fileRecorder,
+            @Inject(required = false) List<List<? extends FileStorage>> fileStorageLists,
+            @Inject(required = false) List<FileStorageAspect> aspectList,
+            @Inject(required = false) List<FileWrapperAdapter> fileWrapperAdapterList,
+            ContentTypeDetect contentTypeDetect,
+            @Inject(required = false) List<List<FileStorageClientFactory<?>>> clientFactoryList) {
+
+        if (fileStorageLists == null) {
+            fileStorageLists = new ArrayList<>();
+        }
+        if (aspectList == null) {
+            aspectList = new ArrayList<>();
+        }
+        if (fileWrapperAdapterList == null) {
+            fileWrapperAdapterList = new ArrayList<>();
+        }
+        if (clientFactoryList == null) {
+            clientFactoryList = new ArrayList<>();
+        }
+
+        FileStorageServiceBuilder builder = FileStorageServiceBuilder.create(properties.toFileStorageProperties())
+                .setFileRecorder(fileRecorder)
+                .setAspectList(aspectList)
+                .setContentTypeDetect(contentTypeDetect)
+                .setFileWrapperAdapterList(fileWrapperAdapterList)
+                .setClientFactoryList(clientFactoryList);
+
+        fileStorageLists.forEach(builder::addFileStorage);
+
+        if (properties.getEnableByteFileWrapper()) {
+            builder.addByteFileWrapperAdapter();
+        }
+        if (properties.getEnableUriFileWrapper()) {
+            builder.addUriFileWrapperAdapter();
+        }
+        if (properties.getEnableInputStreamFileWrapper()) {
+            builder.addInputStreamFileWrapperAdapter();
+        }
+        if (properties.getEnableLocalFileWrapper()) {
+            builder.addLocalFileWrapperAdapter();
+        }
+        if (properties.getEnableHttpServletRequestFileWrapper()) {
+            if (doesNotExistClass("javax.servlet.http.HttpServletRequest")
+                    && doesNotExistClass("jakarta.servlet.http.HttpServletRequest")) {
+                log.warn(
+                        "当前未检测到 Servlet 环境，无法加载 HttpServletRequest 的文件包装适配器，请将参数【dromara.x-file-storage.enable-http-servlet-request-file-wrapper】设置为 【false】来消除此警告");
+            } else {
+                builder.addHttpServletRequestFileWrapperAdapter();
+            }
+        }
+        if (properties.getEnableMultipartFileWrapper()) {
+            log.warn(
+                    "当前为 Solon 环境，无需加载 MultipartFile 的文件包装适配器, 请将参数【dromara.x-file-storage.enable-multipart-file-wrapper】设置为 【false】来消除此警告");
+        }
+
+        if (properties.getEnableUploadedFileWrapper()) {
+            if (doesNotExistClass("org.noear.solon.core.handle.UploadedFile")) {
+                log.warn(
+                        "当前未检测到 Solon 环境，无法加载 UploadedFile 的文件包装适配器，请将参数【dromara.x-file-storage.enable-uploaded-file-wrapper】设置为 【false】来消除此警告");
+            } else {
+                builder.addFileWrapperAdapter(new UploadedFileWrapperAdapter());
+            }
+        }
+
+        if (doesNotExistClass("org.noear.solon.web.staticfiles.StaticMappings")) {
+            long localAccessNum = properties.getLocal().stream()
+                    .filter(SpringLocalConfig::getEnableStorage)
+                    .filter(SpringLocalConfig::getEnableAccess)
+                    .count();
+            long localPlusAccessNum = properties.getLocalPlus().stream()
+                    .filter(SpringLocalPlusConfig::getEnableStorage)
+                    .filter(SpringLocalPlusConfig::getEnableAccess)
+                    .count();
+
+            if (localAccessNum + localPlusAccessNum > 0) {
+                log.warn("当前未检测到 Solon staticfiles 模块，无法开启本地存储平台的本地访问功能，请将关闭本地访问来消除此警告");
+            }
+        }
+
+        return builder.build();
+    }
+
+    /**
+     * 对 FileStorageService 注入自己的代理对象，不然会导致针对 FileStorageService 的代理方法不生效
+     */
+    @Init
+    public void onContextRefreshedEvent() {
+        Solon.context().getBeanAsync(FileStorageService.class, (bean) -> {
+            bean.setSelf(bean);
+        });
+    }
+}
diff --git a/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/SolonFileStorageProperties.java b/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/SolonFileStorageProperties.java
new file mode 100644
index 00000000..a961ab42
--- /dev/null
+++ b/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/SolonFileStorageProperties.java
@@ -0,0 +1,434 @@
+package org.dromara.x.file.storage.solon;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+import org.dromara.x.file.storage.core.FileStorageProperties;
+import org.dromara.x.file.storage.core.FileStorageProperties.*;
+
+/**
+ * @author link2fun
+ */
+@Data
+@Accessors(chain = true)
+public class SolonFileStorageProperties {
+
+    /**
+     * 默认存储平台
+     */
+    private String defaultPlatform = "local";
+    /**
+     * 缩略图后缀，例如【.min.jpg】【.png】
+     */
+    private String thumbnailSuffix = ".min.jpg";
+    /**
+     * 上传时不支持元数据时抛出异常
+     */
+    private Boolean uploadNotSupportMetadataThrowException = true;
+    /**
+     * 上传时不支持 ACL 时抛出异常
+     */
+    private Boolean uploadNotSupportAclThrowException = true;
+    /**
+     * 复制时不支持元数据时抛出异常
+     */
+    private Boolean copyNotSupportMetadataThrowException = true;
+    /**
+     * 复制时不支持 ACL 时抛出异常
+     */
+    private Boolean copyNotSupportAclThrowException = true;
+    /**
+     * 移动时不支持元数据时抛出异常
+     */
+    private Boolean moveNotSupportMetadataThrowException = true;
+    /**
+     * 移动时不支持 ACL 时抛出异常
+     */
+    private Boolean moveNotSupportAclThrowException = true;
+    /**
+     * 启用 byte[] 文件包装适配器
+     */
+    private Boolean enableByteFileWrapper = true;
+    /**
+     * 启用 URI 文件包装适配器，包含 URL 和 String
+     */
+    private Boolean enableUriFileWrapper = true;
+    /**
+     * 启用 InputStream 文件包装适配器
+     */
+    private Boolean enableInputStreamFileWrapper = true;
+    /**
+     * 启用本地文件包装适配器
+     */
+    private Boolean enableLocalFileWrapper = true;
+    /**
+     * 启用 HttpServletRequest 文件包装适配器
+     */
+    private Boolean enableHttpServletRequestFileWrapper = true;
+    /**
+     * 启用 MultipartFile 文件包装适配器
+     */
+    private Boolean enableMultipartFileWrapper = true;
+    /**
+     * 启用 Solon UploadedFile 文件包装适配器
+     */
+    private Boolean enableUploadedFileWrapper = true;
+    /**
+     * 本地存储
+     */
+    @Deprecated
+    private List<? extends SpringLocalConfig> local = new ArrayList<>();
+    /**
+     * 本地存储
+     */
+    private List<? extends SpringLocalPlusConfig> localPlus = new ArrayList<>();
+    /**
+     * 华为云 OBS
+     */
+    private List<? extends SpringHuaweiObsConfig> huaweiObs = new ArrayList<>();
+    /**
+     * 阿里云 OSS
+     */
+    private List<? extends SpringAliyunOssConfig> aliyunOss = new ArrayList<>();
+    /**
+     * 七牛云 Kodo
+     */
+    private List<? extends SpringQiniuKodoConfig> qiniuKodo = new ArrayList<>();
+    /**
+     * 腾讯云 COS
+     */
+    private List<? extends SpringTencentCosConfig> tencentCos = new ArrayList<>();
+    /**
+     * 百度云 BOS
+     */
+    private List<? extends SpringBaiduBosConfig> baiduBos = new ArrayList<>();
+    /**
+     * 又拍云 USS
+     */
+    private List<? extends SpringUpyunUssConfig> upyunUss = new ArrayList<>();
+    /**
+     * MinIO USS
+     */
+    private List<? extends SpringMinioConfig> minio = new ArrayList<>();
+
+    /**
+     * Amazon S3
+     */
+    private List<? extends SpringAmazonS3Config> amazonS3 = new ArrayList<>();
+
+    /**
+     * FTP
+     */
+    private List<? extends SpringFtpConfig> ftp = new ArrayList<>();
+
+    /**
+     * FTP
+     */
+    private List<? extends SpringSftpConfig> sftp = new ArrayList<>();
+
+    /**
+     * WebDAV
+     */
+    private List<? extends SpringWebDavConfig> webdav = new ArrayList<>();
+
+    /**
+     * GoogleCloud Storage
+     */
+    private List<? extends SpringGoogleCloudStorageConfig> googleCloudStorage = new ArrayList<>();
+
+    /**
+     * FastDFS
+     */
+    private List<? extends SpringFastDfsConfig> fastdfs = new ArrayList<>();
+
+    /**
+     * Azure Blob Storage
+     */
+    private List<? extends SpringAzureBlobStorageConfig> azureBlob = new ArrayList<>();
+
+    /**
+     * 转换成 FileStorageProperties ，并过滤掉没有启用的存储平台
+     */
+    public FileStorageProperties toFileStorageProperties() {
+        FileStorageProperties properties = new FileStorageProperties();
+        properties.setDefaultPlatform(defaultPlatform);
+        properties.setThumbnailSuffix(thumbnailSuffix);
+        properties.setUploadNotSupportMetadataThrowException(uploadNotSupportMetadataThrowException);
+        properties.setUploadNotSupportAclThrowException(uploadNotSupportAclThrowException);
+        properties.setCopyNotSupportMetadataThrowException(copyNotSupportMetadataThrowException);
+        properties.setCopyNotSupportAclThrowException(copyNotSupportAclThrowException);
+        properties.setMoveNotSupportMetadataThrowException(moveNotSupportMetadataThrowException);
+        properties.setMoveNotSupportAclThrowException(moveNotSupportAclThrowException);
+        properties.setLocal(
+                local.stream().filter(SpringLocalConfig::getEnableStorage).collect(Collectors.toList()));
+        properties.setLocalPlus(localPlus.stream()
+                .filter(SpringLocalPlusConfig::getEnableStorage)
+                .collect(Collectors.toList()));
+        properties.setHuaweiObs(huaweiObs.stream()
+                .filter(SpringHuaweiObsConfig::getEnableStorage)
+                .collect(Collectors.toList()));
+        properties.setAliyunOss(aliyunOss.stream()
+                .filter(SpringAliyunOssConfig::getEnableStorage)
+                .collect(Collectors.toList()));
+        properties.setQiniuKodo(qiniuKodo.stream()
+                .filter(SpringQiniuKodoConfig::getEnableStorage)
+                .collect(Collectors.toList()));
+        properties.setTencentCos(tencentCos.stream()
+                .filter(SpringTencentCosConfig::getEnableStorage)
+                .collect(Collectors.toList()));
+        properties.setBaiduBos(
+                baiduBos.stream().filter(SpringBaiduBosConfig::getEnableStorage).collect(Collectors.toList()));
+        properties.setUpyunUss(
+                upyunUss.stream().filter(SpringUpyunUssConfig::getEnableStorage).collect(Collectors.toList()));
+        properties.setMinio(
+                minio.stream().filter(SpringMinioConfig::getEnableStorage).collect(Collectors.toList()));
+        properties.setAmazonS3(
+                amazonS3.stream().filter(SpringAmazonS3Config::getEnableStorage).collect(Collectors.toList()));
+        properties.setFtp(ftp.stream().filter(SpringFtpConfig::getEnableStorage).collect(Collectors.toList()));
+        properties.setSftp(
+                sftp.stream().filter(SpringSftpConfig::getEnableStorage).collect(Collectors.toList()));
+        properties.setWebdav(
+                webdav.stream().filter(SpringWebDavConfig::getEnableStorage).collect(Collectors.toList()));
+        properties.setGoogleCloudStorage(googleCloudStorage.stream()
+                .filter(SpringGoogleCloudStorageConfig::getEnableStorage)
+                .collect(Collectors.toList()));
+        properties.setFastdfs(
+                fastdfs.stream().filter(SpringFastDfsConfig::getEnableStorage).collect(Collectors.toList()));
+        properties.setAzureBlob(azureBlob.stream()
+                .filter(SpringAzureBlobStorageConfig::getEnableStorage)
+                .collect(Collectors.toList()));
+
+        return properties;
+    }
+
+    /**
+     * 本地存储
+     */
+    @Deprecated
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringLocalConfig extends LocalConfig {
+        /**
+         * 本地存储访问路径
+         */
+        private String pathPatterns;
+        /**
+         * 启用本地存储
+         */
+        private Boolean enableStorage = false;
+        /**
+         * 启用本地访问
+         */
+        private Boolean enableAccess = false;
+    }
+
+    /**
+     * 本地存储升级版
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringLocalPlusConfig extends LocalPlusConfig {
+        /**
+         * 本地存储访问路径
+         */
+        private String pathPatterns;
+        /**
+         * 启用本地存储
+         */
+        private Boolean enableStorage = false;
+        /**
+         * 启用本地访问
+         */
+        private Boolean enableAccess = false;
+    }
+
+    /**
+     * 华为云 OBS
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringHuaweiObsConfig extends HuaweiObsConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * 阿里云 OSS
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringAliyunOssConfig extends AliyunOssConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * 七牛云 Kodo
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringQiniuKodoConfig extends QiniuKodoConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * 腾讯云 COS
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringTencentCosConfig extends TencentCosConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * 百度云 BOS
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringBaiduBosConfig extends BaiduBosConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * 又拍云 USS
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringUpyunUssConfig extends UpyunUssConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * MinIO
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringMinioConfig extends MinioConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * Amazon S3
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringAmazonS3Config extends AmazonS3Config {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * FTP
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringFtpConfig extends FtpConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * SFTP
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringSftpConfig extends SftpConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * WebDAV
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringWebDavConfig extends WebDavConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * GoogleCloud Storage
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringGoogleCloudStorageConfig extends GoogleCloudStorageConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * FastDFS Storage
+     *
+     * @author XS <wanghaiqi@beeplay123.com>
+     * @date 2023/10/23
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringFastDfsConfig extends FastDfsConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+
+    /**
+     * AzureBlob Storage
+     */
+    @Data
+    @Accessors(chain = true)
+    @EqualsAndHashCode(callSuper = true)
+    public static class SpringAzureBlobStorageConfig extends AzureBlobStorageConfig {
+        /**
+         * 启用存储
+         */
+        private Boolean enableStorage = false;
+    }
+}
diff --git a/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/file/UploadedFileWrapper.java b/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/file/UploadedFileWrapper.java
new file mode 100644
index 00000000..6bed2c7a
--- /dev/null
+++ b/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/file/UploadedFileWrapper.java
@@ -0,0 +1,64 @@
+package org.dromara.x.file.storage.solon.file;
+
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.io.IoUtil;
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.InputStream;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.dromara.x.file.storage.core.exception.FileStorageRuntimeException;
+import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.noear.solon.core.handle.UploadedFile;
+
+/**
+ * Solon UploadedFile 文件包装类
+ *
+ * @author link2fun
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+public class UploadedFileWrapper implements FileWrapper {
+
+    private UploadedFile file;
+    private String name;
+    private String contentType;
+    private InputStream inputStream;
+    private Long size;
+
+    public UploadedFileWrapper(UploadedFile file, String name, String contentType, Long size) {
+        this.file = file;
+        this.name = name;
+        this.contentType = contentType;
+        this.size = size;
+    }
+
+    @Override
+    public InputStream getInputStream() {
+        if (inputStream == null) {
+            inputStream = new BufferedInputStream(file.getContent());
+        }
+        return inputStream;
+    }
+
+    @Override
+    public void transferTo(final File dest) {
+        try {
+            file.transferTo(dest);
+            IoUtil.close(inputStream);
+        } catch (Exception ignored) {
+            try {
+                FileUtil.writeFromStream(getInputStream(), dest);
+            } catch (Exception e) {
+                throw new FileStorageRuntimeException("文件移动失败", e);
+            }
+        }
+    }
+
+    @Override
+    public boolean supportTransfer() {
+        return true;
+    }
+}
diff --git a/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/file/UploadedFileWrapperAdapter.java b/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/file/UploadedFileWrapperAdapter.java
new file mode 100644
index 00000000..5f6de569
--- /dev/null
+++ b/x-file-storage-solon/src/main/java/org/dromara/x/file/storage/solon/file/UploadedFileWrapperAdapter.java
@@ -0,0 +1,39 @@
+package org.dromara.x.file.storage.solon.file;
+
+import java.io.IOException;
+import java.util.Optional;
+import lombok.Getter;
+import lombok.Setter;
+import org.dromara.x.file.storage.core.file.FileWrapper;
+import org.dromara.x.file.storage.core.file.FileWrapperAdapter;
+import org.noear.solon.core.handle.UploadedFile;
+
+/**
+ * Solon UploadedFile 文件包装适配器
+ *
+ * @author link2fun
+ */
+@Getter
+@Setter
+public class UploadedFileWrapperAdapter implements FileWrapperAdapter {
+
+    @Override
+    public boolean isSupport(final Object source) {
+        return source instanceof UploadedFile || source instanceof UploadedFileWrapper;
+    }
+
+    @Override
+    public FileWrapper getFileWrapper(final Object source, final String name, final String contentType, final Long size)
+            throws IOException {
+        if (source instanceof UploadedFileWrapper) {
+            return updateFileWrapper((UploadedFileWrapper) source, name, contentType, size);
+        } else {
+            UploadedFile file = (UploadedFile) source;
+            return new UploadedFileWrapper(
+                    file,
+                    Optional.ofNullable(name).orElseGet(file::getName),
+                    Optional.ofNullable(contentType).orElseGet(file::getContentType),
+                    Optional.ofNullable(size).orElseGet(file::getContentSize));
+        }
+    }
+}
diff --git a/x-file-storage-solon/src/main/resources/META-INF/solon/solon.dromara.x-file-storage.properties b/x-file-storage-solon/src/main/resources/META-INF/solon/solon.dromara.x-file-storage.properties
new file mode 100644
index 00000000..bda5bd03
--- /dev/null
+++ b/x-file-storage-solon/src/main/resources/META-INF/solon/solon.dromara.x-file-storage.properties
@@ -0,0 +1,2 @@
+solon.plugin=org.dromara.x.file.storage.solon.DromaraXFileStoragePluginImpl
+solon.plugin.priority=1
\ No newline at end of file
diff --git a/x-file-storage-spring/src/main/java/org/dromara/x/file/storage/spring/FileStorageAutoConfiguration.java b/x-file-storage-spring/src/main/java/org/dromara/x/file/storage/spring/FileStorageAutoConfiguration.java
index c5943cb9..e3b28430 100644
--- a/x-file-storage-spring/src/main/java/org/dromara/x/file/storage/spring/FileStorageAutoConfiguration.java
+++ b/x-file-storage-spring/src/main/java/org/dromara/x/file/storage/spring/FileStorageAutoConfiguration.java
@@ -43,31 +43,6 @@ public class FileStorageAutoConfiguration {
     @Autowired
     private ApplicationContext applicationContext;
 
-    /**
-     * 配置本地存储的访问地址
-     */
-    @Bean
-    @ConditionalOnClass(name = "org.springframework.web.servlet.config.annotation.WebMvcConfigurer")
-    public Object fileStorageWebMvcConfigurer() {
-        return new WebMvcConfigurer() {
-            @Override
-            public void addResourceHandlers(@NonNull ResourceHandlerRegistry registry) {
-                for (SpringLocalConfig local : properties.getLocal()) {
-                    if (local.getEnableStorage() && local.getEnableAccess()) {
-                        registry.addResourceHandler(local.getPathPatterns())
-                                .addResourceLocations("file:" + local.getBasePath());
-                    }
-                }
-                for (SpringLocalPlusConfig local : properties.getLocalPlus()) {
-                    if (local.getEnableStorage() && local.getEnableAccess()) {
-                        registry.addResourceHandler(local.getPathPatterns())
-                                .addResourceLocations("file:" + local.getStoragePath());
-                    }
-                }
-            }
-        };
-    }
-
     /**
      * 当没有找到 FileRecorder 时使用默认的 FileRecorder
      */
@@ -178,4 +153,38 @@ public void onContextRefreshedEvent() {
         FileStorageService service = applicationContext.getBean(FileStorageService.class);
         service.setSelf(service);
     }
+
+    /**
+     * 本地存储文件访问自动配置类
+     */
+    @Configuration
+    @ConditionalOnClass(name = "org.springframework.web.servlet.config.annotation.WebMvcConfigurer")
+    public static class FileStorageLocalFileAccessAutoConfiguration {
+        @Autowired
+        private SpringFileStorageProperties properties;
+
+        /**
+         * 配置本地存储的访问地址
+         */
+        @Bean
+        public WebMvcConfigurer fileStorageWebMvcConfigurer() {
+            return new WebMvcConfigurer() {
+                @Override
+                public void addResourceHandlers(@NonNull ResourceHandlerRegistry registry) {
+                    for (SpringLocalConfig local : properties.getLocal()) {
+                        if (local.getEnableStorage() && local.getEnableAccess()) {
+                            registry.addResourceHandler(local.getPathPatterns())
+                                    .addResourceLocations("file:" + local.getBasePath());
+                        }
+                    }
+                    for (SpringLocalPlusConfig local : properties.getLocalPlus()) {
+                        if (local.getEnableStorage() && local.getEnableAccess()) {
+                            registry.addResourceHandler(local.getPathPatterns())
+                                    .addResourceLocations("file:" + local.getStoragePath());
+                        }
+                    }
+                }
+            };
+        }
+    }
 }
diff --git a/x-file-storage-tests/x-file-storage-general-test/pom.xml b/x-file-storage-tests/x-file-storage-general-test/pom.xml
index 7494e434..589eaba7 100644
--- a/x-file-storage-tests/x-file-storage-general-test/pom.xml
+++ b/x-file-storage-tests/x-file-storage-general-test/pom.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <groupId>org.dromara.x-file-storage</groupId>
@@ -27,6 +28,12 @@
             <groupId>cn.hutool</groupId>
             <artifactId>hutool-extra</artifactId>
         </dependency>
+        <!--糊涂加解密相关工具类-->
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-crypto</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
@@ -58,15 +65,15 @@
         <!--            <artifactId>commons-net</artifactId>-->
         <!--        </dependency>-->
         <!-- Amazon S3 -->
-        <!--        <dependency>-->
-        <!--            <groupId>com.amazonaws</groupId>-->
-        <!--            <artifactId>aws-java-sdk-s3</artifactId>-->
-        <!--        </dependency>-->
+                <dependency>
+                    <groupId>com.amazonaws</groupId>
+                    <artifactId>aws-java-sdk-s3</artifactId>
+                </dependency>
         <!-- MinIO -->
-        <!--        <dependency>-->
-        <!--            <groupId>io.minio</groupId>-->
-        <!--            <artifactId>minio</artifactId>-->
-        <!--        </dependency>-->
+                <dependency>
+                    <groupId>io.minio</groupId>
+                    <artifactId>minio</artifactId>
+                </dependency>
         <!-- 又拍云 USS -->
         <!--        <dependency>-->
         <!--            <groupId>com.upyun</groupId>-->
@@ -78,20 +85,20 @@
         <!--            <artifactId>bce-java-sdk</artifactId>-->
         <!--        </dependency>-->
         <!-- 腾讯云 COS -->
-        <!--        <dependency>-->
-        <!--            <groupId>com.qcloud</groupId>-->
-        <!--            <artifactId>cos_api</artifactId>-->
-        <!--        </dependency>-->
+                <dependency>
+                    <groupId>com.qcloud</groupId>
+                    <artifactId>cos_api</artifactId>
+                </dependency>
         <!-- 七牛云 Kodo -->
         <!--        <dependency>-->
         <!--            <groupId>com.qiniu</groupId>-->
         <!--            <artifactId>qiniu-java-sdk</artifactId>-->
         <!--        </dependency>-->
         <!-- 阿里云 OSS -->
-        <!--        <dependency>-->
-        <!--            <groupId>com.aliyun.oss</groupId>-->
-        <!--            <artifactId>aliyun-sdk-oss</artifactId>-->
-        <!--        </dependency>-->
+                <dependency>
+                    <groupId>com.aliyun.oss</groupId>
+                    <artifactId>aliyun-sdk-oss</artifactId>
+                </dependency>
         <!-- 华为云 OBS -->
         <dependency>
             <groupId>com.huaweicloud</groupId>
@@ -109,14 +116,14 @@
         <!--            <artifactId>fastdfs-client-java</artifactId>-->
         <!--        </dependency>-->
         <!-- Azure Blob -->
-        <!--        <dependency>-->
-        <!--            <groupId>com.azure</groupId>-->
-        <!--            <artifactId>azure-storage-blob</artifactId>-->
-        <!--        </dependency>-->
+                <dependency>
+                    <groupId>com.azure</groupId>
+                    <artifactId>azure-storage-blob</artifactId>
+                </dependency>
         <!-- Azure File Data Lake 用于处理 ACL -->
-        <!--        <dependency>-->
-        <!--            <groupId>com.azure</groupId>-->
-        <!--            <artifactId>azure-storage-file-datalake</artifactId>-->
-        <!--        </dependency>-->
+                <dependency>
+                    <groupId>com.azure</groupId>
+                    <artifactId>azure-storage-file-datalake</artifactId>
+                </dependency>
     </dependencies>
 </project>
diff --git a/x-file-storage-tests/x-file-storage-general-test/src/main/java/org/dromara/x/file/storage/test/aspect/LogFileStorageAspect.java b/x-file-storage-tests/x-file-storage-general-test/src/main/java/org/dromara/x/file/storage/test/aspect/LogFileStorageAspect.java
index d6c70cb4..468e2838 100644
--- a/x-file-storage-tests/x-file-storage-general-test/src/main/java/org/dromara/x/file/storage/test/aspect/LogFileStorageAspect.java
+++ b/x-file-storage-tests/x-file-storage-general-test/src/main/java/org/dromara/x/file/storage/test/aspect/LogFileStorageAspect.java
@@ -1,5 +1,6 @@
 package org.dromara.x.file.storage.test.aspect;
 
+import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.util.ArrayUtil;
 import java.io.InputStream;
 import java.util.Date;
@@ -9,12 +10,15 @@
 import org.dromara.x.file.storage.core.UploadPretreatment;
 import org.dromara.x.file.storage.core.aspect.*;
 import org.dromara.x.file.storage.core.copy.CopyPretreatment;
+import org.dromara.x.file.storage.core.get.*;
 import org.dromara.x.file.storage.core.move.MovePretreatment;
 import org.dromara.x.file.storage.core.platform.FileStorage;
-import org.dromara.x.file.storage.core.platform.MultipartUploadSupportInfo;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlPretreatment;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
 import org.dromara.x.file.storage.core.recorder.FileRecorder;
 import org.dromara.x.file.storage.core.tika.ContentTypeDetect;
 import org.dromara.x.file.storage.core.upload.*;
+import org.dromara.x.file.storage.core.upload.MultipartUploadSupportInfo;
 import org.springframework.stereotype.Component;
 
 /**
@@ -125,6 +129,39 @@ public FilePartInfoList listParts(ListPartsAspectChain chain, ListPartsPretreatm
         return list;
     }
 
+    /**
+     * 是否支持列举文件
+     */
+    @Override
+    public ListFilesSupportInfo isSupportListFiles(IsSupportListFilesAspectChain chain, FileStorage fileStorage) {
+        log.info("是否支持列举文件 before -> {}", fileStorage.getPlatform());
+        ListFilesSupportInfo res = chain.next(fileStorage);
+        log.info("是否支持列举文件 -> {}", res);
+        return res;
+    }
+
+    /**
+     * 列举文件
+     */
+    @Override
+    public ListFilesResult listFiles(ListFilesAspectChain chain, ListFilesPretreatment pre, FileStorage fileStorage) {
+        log.info("列举文件 before -> {}", BeanUtil.beanToMap(pre, "fileStorageService"));
+        ListFilesResult result = chain.next(pre, fileStorage);
+        log.info("列举文件 after -> {}", result);
+        return result;
+    }
+
+    /**
+     * 获取文件
+     */
+    @Override
+    public RemoteFileInfo getFile(GetFileAspectChain chain, GetFilePretreatment pre, FileStorage fileStorage) {
+        log.info("获取文件 before -> {}", BeanUtil.beanToMap(pre, "fileStorageService"));
+        RemoteFileInfo result = chain.next(pre, fileStorage);
+        log.info("获取文件 after -> {}", result);
+        return result;
+    }
+
     /**
      * 删除文件，成功返回 true
      */
@@ -185,10 +222,10 @@ public boolean isSupportPresignedUrlAround(IsSupportPresignedUrlAspectChain chai
      * 对文件生成可以签名访问的 URL，无法生成则返回 null
      */
     @Override
-    public String generatePresignedUrlAround(
-            GeneratePresignedUrlAspectChain chain, FileInfo fileInfo, Date expiration, FileStorage fileStorage) {
-        log.info("对文件生成可以签名访问的 URL before -> {}", fileInfo);
-        String res = chain.next(fileInfo, expiration, fileStorage);
+    public GeneratePresignedUrlResult generatePresignedUrlAround(
+            GeneratePresignedUrlAspectChain chain, GeneratePresignedUrlPretreatment pre, FileStorage fileStorage) {
+        log.info("对文件生成可以签名访问的 URL before -> {}", BeanUtil.beanToMap(pre, "fileStorageService"));
+        GeneratePresignedUrlResult res = chain.next(pre, fileStorage);
         log.info("对文件生成可以签名访问的 URL after -> {}", res);
         return res;
     }
diff --git a/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceBaseTest.java b/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceBaseTest.java
index f0627e83..4d8f013f 100644
--- a/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceBaseTest.java
+++ b/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceBaseTest.java
@@ -103,7 +103,7 @@ public void uploadUserMetadata() {
         String filename = "image.jpg";
         InputStream in = this.getClass().getClassLoader().getResourceAsStream(filename);
 
-        // 是否支持 ACL
+        // 是否支持 Metadata
         FileStorage storage = fileStorageService.getFileStorage();
         boolean supportMetadata = fileStorageService.isSupportMetadata(storage);
         if (!supportMetadata) {
diff --git a/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceGeneratePresignedUrlTest.java b/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceGeneratePresignedUrlTest.java
new file mode 100644
index 00000000..2e149144
--- /dev/null
+++ b/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceGeneratePresignedUrlTest.java
@@ -0,0 +1,172 @@
+package org.dromara.x.file.storage.test;
+
+import cn.hutool.core.date.DateUtil;
+import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.lang.Assert;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.http.HttpRequest;
+import cn.hutool.http.HttpUtil;
+import cn.hutool.http.Method;
+import java.util.Arrays;
+import java.util.Date;
+import lombok.extern.slf4j.Slf4j;
+import org.dromara.x.file.storage.core.FileInfo;
+import org.dromara.x.file.storage.core.FileStorageService;
+import org.dromara.x.file.storage.core.constant.Constant;
+import org.dromara.x.file.storage.core.presigned.GeneratePresignedUrlResult;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@Slf4j
+@SpringBootTest
+class FileStorageServiceGeneratePresignedUrlTest {
+
+    @Autowired
+    private FileStorageService fileStorageService;
+
+    /**
+     * 测试生成预签名 URL
+     */
+    @Test
+    public void generatePresignedUrl() {
+        if (!fileStorageService.isSupportPresignedUrl()) {
+            log.info("暂不支持生成预签名 URL");
+            return;
+        }
+
+        byte[] bytes = IoUtil.readBytes(this.getClass().getClassLoader().getResourceAsStream("image.jpg"));
+
+        // ======================= 测试上传 =======================
+        GeneratePresignedUrlResult result = upload(bytes);
+        // ======================= 测试访问 =======================
+        download(result.getPath(), result.getFilename(), bytes);
+        // ======================= 测试删除 =======================
+        //        delete(result.getPlatform(), result.getBasePath(), result.getPath(), result.getFilename());
+    }
+
+    /**
+     * 测试生成预签名 URL，主要用来测试 specialParam （特殊操作符）
+     */
+    @Test
+    public void generatePresignedUrlSpecialParam() {
+        if (!fileStorageService.isSupportPresignedUrl()) {
+            log.info("暂不支持生成预签名 URL");
+            return;
+        }
+        // ======================= 测试初始化分段上传任务 =====================
+        GeneratePresignedUrlResult result = multipartUploadInit();
+        // ======================= 测试删除分段上传任务 =====================
+        delete(result.getPlatform(), result.getBasePath(), result.getPath(), result.getFilename());
+    }
+
+    /**
+     * 测试分段上传-初始化
+     */
+    public GeneratePresignedUrlResult multipartUploadInit() {
+        GeneratePresignedUrlResult result = fileStorageService
+                .generatePresignedUrl()
+                .setPath("test/")
+                .setFilename("image-m.jpg")
+                .setMethod(Constant.GeneratePresignedUrl.Method.POST)
+                .putHeaders(Constant.Metadata.CONTENT_TYPE, "image/jpeg")
+                .setSpecialParam("UPLOADS")
+                .setExpiration(DateUtil.offsetMinute(new Date(), 10))
+                .generatePresignedUrl();
+        Assert.notNull(result, "生成分段上传任务-初始化任务预签名 URL 失败！");
+        log.info("生成分段上传任务-初始化预签名 URL 结果：{}", result);
+
+        String response = HttpRequest.of(result.getUrl())
+                .method(Method.POST)
+                .addHeaders(result.getHeaders())
+                .execute()
+                .body();
+
+        String uploadId = StrUtil.subBetween(response, "<UploadId>", "</UploadId>");
+        log.info("生成分段上传任务-初始化任务结果 uploadId：{}", uploadId);
+        Assert.notBlank(uploadId, "生成分段上传任务-初始化任务预签名 URL 失败，uploadId 为空！");
+        return result;
+    }
+
+    /**
+     * 测试上传
+     */
+    private GeneratePresignedUrlResult upload(byte[] bytes) {
+
+        GeneratePresignedUrlResult uploadResult = fileStorageService
+                .generatePresignedUrl()
+                .setPath("test/")
+                .setFilename("image.jpg")
+                .setMethod(Constant.GeneratePresignedUrl.Method.PUT)
+                .setExpiration(DateUtil.offsetMinute(new Date(), 10))
+                .putHeaders(Constant.Metadata.CONTENT_TYPE, "image/jpeg")
+                .putHeaders(Constant.Metadata.CONTENT_DISPOSITION, "attachment;filename=DownloadFileName.jpg")
+                .putUserMetadata("role", "666")
+                .putQueryParams("admin", "123456")
+                .generatePresignedUrl();
+        Assert.notNull(uploadResult, "生成上传预签名 URL 失败！");
+        log.info("生成上传预签名 URL 结果：{}", uploadResult);
+        String body = HttpRequest.of(uploadResult.getUrl())
+                .method(Method.PUT)
+                .addHeaders(uploadResult.getHeaders())
+                .body(bytes)
+                .execute()
+                .body();
+        Assert.isTrue(StrUtil.isBlank(body), "生成上传预签名 URL 失败：{}", body);
+
+        log.info("上传成功");
+        return uploadResult;
+    }
+
+    /**
+     * 测试访问
+     */
+    private void download(String path, String filename, byte[] bytes) {
+        GeneratePresignedUrlResult downloadResult = fileStorageService
+                .generatePresignedUrl()
+                .setPath(path)
+                .setFilename(filename)
+                .setMethod(Constant.GeneratePresignedUrl.Method.GET)
+                .setExpiration(DateUtil.offsetMinute(new Date(), 10))
+                .putResponseHeaders(
+                        Constant.Metadata.CONTENT_DISPOSITION, "attachment;filename=NewDownloadFileName.jpg")
+                .generatePresignedUrl();
+        Assert.notNull(downloadResult, "生成访问预签名 URL 失败！");
+        log.info("生成访问预签名 URL 结果：{}", downloadResult);
+        try {
+            byte[] downloadBytes = HttpUtil.downloadBytes(downloadResult.getUrl());
+            Assert.notNull(downloadBytes);
+            Assert.isTrue(Arrays.equals(downloadBytes, bytes));
+        } catch (Exception e) {
+            Assert.isTrue(false, "生成访问预签名 URL 失败，无法访问 URL");
+        }
+        log.info("生成访问预签名 URL 通过");
+    }
+
+    /**
+     * 测试删除
+     */
+    private void delete(String platform, String basePath, String path, String filename) {
+        GeneratePresignedUrlResult deleteResult = fileStorageService
+                .generatePresignedUrl()
+                .setPath("test/")
+                .setFilename("image.jpg")
+                .setMethod(Constant.GeneratePresignedUrl.Method.DELETE)
+                .setExpiration(DateUtil.offsetMinute(new Date(), 10))
+                // Hutool HTTP 工具默认发送的 Content-Type 是 application/x-www-form-urlencoded
+                // 会导致签名错误，这里强制传入一个 Content-Type 用于覆盖默认的可以解决这个问题
+                // 其它请求工具类可以忽略这个参数
+                .putHeaders(Constant.Metadata.CONTENT_TYPE, "image/jpeg")
+                .generatePresignedUrl();
+
+        String deleteHttpResponse = HttpRequest.of(deleteResult.getUrl())
+                .method(Method.DELETE)
+                .addHeaders(deleteResult.getHeaders())
+                .execute()
+                .body();
+
+        boolean exists = fileStorageService.exists(new FileInfo(basePath, path, filename).setPlatform(platform));
+        Assert.isFalse(exists, "删除失败：{}", deleteHttpResponse);
+        log.info("删除成功");
+    }
+}
diff --git a/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceGetTest.java b/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceGetTest.java
new file mode 100644
index 00000000..0ba8fb4f
--- /dev/null
+++ b/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceGetTest.java
@@ -0,0 +1,92 @@
+package org.dromara.x.file.storage.test;
+
+import cn.hutool.core.lang.Assert;
+import java.io.InputStream;
+import lombok.extern.slf4j.Slf4j;
+import org.dromara.x.file.storage.core.FileInfo;
+import org.dromara.x.file.storage.core.FileStorageService;
+import org.dromara.x.file.storage.core.constant.Constant;
+import org.dromara.x.file.storage.core.get.ListFilesResult;
+import org.dromara.x.file.storage.core.get.ListFilesSupportInfo;
+import org.dromara.x.file.storage.core.get.RemoteFileInfo;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@Slf4j
+@SpringBootTest
+class FileStorageServiceGetTest {
+
+    @Autowired
+    private FileStorageService fileStorageService;
+
+    /**
+     * 测试列举文件
+     */
+    @Test
+    public void listFiles() {
+        ListFilesSupportInfo isSupportListFiles = fileStorageService.isSupportListFiles();
+        if (!isSupportListFiles.getIsSupport()) {
+            log.info("暂不支持列举文件");
+            return;
+        }
+
+        ListFilesResult result = fileStorageService.listFiles().setPath("test/").listFiles();
+
+        result.getDirList().forEach(info -> log.info("目录：{}", info));
+        log.info("列举目录完成，共 {} 个目录", result.getDirList().size());
+        result.getFileList().forEach(info -> log.info("文件：{}", info));
+        log.info("列举文件完成，共 {} 个文件", result.getFileList().size());
+        log.info("列举文件全部结果：{}", result);
+    }
+
+    public FileInfo upload() {
+        String filename = "image.jpg";
+        InputStream in = this.getClass().getClassLoader().getResourceAsStream(filename);
+        FileInfo fileInfo = fileStorageService
+                .of(in)
+                .setName("file")
+                .setOriginalFilename(filename)
+                .setPath("test/")
+                .setNotSupportAclThrowException(false)
+                .setFileAcl(Constant.ACL.PUBLIC_READ)
+                .setNotSupportMetadataThrowException(false)
+                .putMetadata(Constant.Metadata.CONTENT_DISPOSITION, "attachment;filename=DownloadFileName.jpg")
+                .putMetadata("Test-Not-Support", "123456") // 测试不支持的元数据
+                .putUserMetadata("role", "666")
+                .upload();
+        Assert.notNull(fileInfo, "文件上传失败！");
+        log.info("文件上传成功：{}", fileInfo.toString());
+        return fileInfo;
+    }
+
+    /**
+     * 测试获取文件
+     */
+    @Test
+    public void getFile() {
+        FileInfo fileInfo = upload();
+
+        RemoteFileInfo info = fileStorageService
+                .getFile()
+                .setPath(fileInfo.getPath())
+                .setFilename(fileInfo.getFilename())
+                .setUrl(fileInfo.getUrl())
+                .getFile();
+        Assert.notNull(info, "获取文件失败！");
+        log.info("获取文件结果：{}", info);
+
+        FileInfo fileInfo2 = info.toFileInfo();
+        log.info("文件结果转成 FileInfo：{}", fileInfo2);
+
+        fileStorageService.delete(fileInfo);
+
+        RemoteFileInfo info2 = fileStorageService
+                .getFile()
+                .setPath(fileInfo.getPath())
+                .setFilename(fileInfo.getFilename())
+                .getFile();
+        Assert.isNull(info2, "获取不存在的文件失败！");
+        log.info("获取不存在的文件结果：{}", info2);
+    }
+}
diff --git a/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceMultipartUploadTest.java b/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceMultipartUploadTest.java
index a4de15d1..e58b95e1 100644
--- a/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceMultipartUploadTest.java
+++ b/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceMultipartUploadTest.java
@@ -3,6 +3,7 @@
 import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IoUtil;
 import cn.hutool.core.lang.Assert;
+import cn.hutool.crypto.SecureUtil;
 import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.IOException;
@@ -12,11 +13,12 @@
 import org.dromara.x.file.storage.core.FileStorageService;
 import org.dromara.x.file.storage.core.ProgressListener;
 import org.dromara.x.file.storage.core.constant.Constant;
+import org.dromara.x.file.storage.core.hash.HashInfo;
 import org.dromara.x.file.storage.core.platform.FileStorage;
-import org.dromara.x.file.storage.core.platform.MultipartUploadSupportInfo;
 import org.dromara.x.file.storage.core.platform.UpyunUssFileStorage;
 import org.dromara.x.file.storage.core.upload.FilePartInfo;
 import org.dromara.x.file.storage.core.upload.FilePartInfoList;
+import org.dromara.x.file.storage.core.upload.MultipartUploadSupportInfo;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
@@ -110,6 +112,12 @@ public void finish() {
                         .setHashCalculatorSha256()
                         .upload();
                 log.info("手动分片上传-分片上传成功：{}", filePartInfo);
+
+                HashInfo hashInfo = filePartInfo.getHashInfo();
+                Assert.isTrue(SecureUtil.md5().digestHex(bytes).equals(hashInfo.getMd5()), "分片 MD5 对比不一致！");
+                log.info("分片 MD5 对比通过");
+                Assert.isTrue(SecureUtil.sha256().digestHex(bytes).equals(hashInfo.getSha256()), "分片 SHA256 对比不一致！");
+                log.info("分片 SHA256 对比通过");
             }
         }
 
@@ -172,6 +180,9 @@ public void abort() throws IOException {
                 .setSaveFilename("BadApple.mp4")
                 .init();
 
+        FilePartInfoList partList = fileStorageService.listParts(fileInfo).listParts();
+        Assert.notNull(partList, "手动分片上传文件初始化失败，无法获取分片信息");
+        Assert.isTrue(partList.getList().isEmpty(), "手动分片上传文件初始化失败，分片信息不为空");
         log.info("手动分片上传文件初始化成功：{}", fileInfo);
 
         try (BufferedInputStream in = FileUtil.getInputStream(file)) {
@@ -186,7 +197,7 @@ public void abort() throws IOException {
             }
         }
 
-        FilePartInfoList partList = fileStorageService.listParts(fileInfo).listParts();
+        partList = fileStorageService.listParts(fileInfo).listParts();
         for (FilePartInfo info : partList.getList()) {
             log.info("手动分片上传-列举已上传的分片：{}", info);
         }
diff --git a/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceTransferTest.java b/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceTransferTest.java
new file mode 100644
index 00000000..25fe105c
--- /dev/null
+++ b/x-file-storage-tests/x-file-storage-general-test/src/test/java/org/dromara/x/file/storage/test/FileStorageServiceTransferTest.java
@@ -0,0 +1,158 @@
+package org.dromara.x.file.storage.test;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import lombok.extern.slf4j.Slf4j;
+import org.dromara.x.file.storage.core.FileInfo;
+import org.dromara.x.file.storage.core.FileStorageService;
+import org.dromara.x.file.storage.core.constant.Constant;
+import org.dromara.x.file.storage.core.get.ListFilesResult;
+import org.dromara.x.file.storage.core.get.RemoteDirInfo;
+import org.dromara.x.file.storage.core.get.RemoteFileInfo;
+import org.dromara.x.file.storage.core.util.KebabCaseInsensitiveMap;
+import org.dromara.x.file.storage.test.service.FileDetailService;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@Slf4j
+@SpringBootTest
+class FileStorageServiceTransferTest {
+
+    @Autowired
+    private FileStorageService fileStorageService;
+
+    @Autowired
+    private FileDetailService fileDetailService;
+
+    /**
+     * 使用数据库迁移文件
+     */
+    @Test
+    public void transferByDb() {
+        // 目标存储平台
+        String toPlatform = "azure-blob-1";
+
+        // 从数据库中读取要迁移的文件信息
+        List<FileInfo> list = fileDetailService.list().stream()
+                .map(detail -> {
+                    try {
+                        return fileDetailService.toFileInfo(detail);
+                    } catch (JsonProcessingException e) {
+                        throw new RuntimeException(e);
+                    }
+                })
+                .collect(Collectors.toList());
+
+        for (FileInfo fileInfo : list) {
+            // 使用复制文件，会保留旧文件，推荐
+            fileStorageService
+                    .copy(fileInfo)
+                    .setPlatform(toPlatform)
+                    .setNotSupportMetadataThrowException(true) // 不支持元数据时抛出异常
+                    .setNotSupportAclThrowException(true) // 不支持 ACL 时抛出异常
+                    .setProgressListener((progressSize, allSize) -> log.info(
+                            "文件 {}{}{} 迁移进度：{} {}%",
+                            fileInfo.getBasePath(),
+                            fileInfo.getPath(),
+                            fileInfo.getFilename(),
+                            progressSize,
+                            progressSize * 100 / allSize))
+                    .copy();
+
+            // 使用移动文件，会删除旧文件，不推荐
+            // fileStorageService
+            //        .move(fileInfo)
+            //        .setPlatform(toPlatform)
+            //        .setNotSupportMetadataThrowException(true) // 不支持元数据时抛出异常
+            //        .setNotSupportAclThrowException(true) // 不支持 ACL 时抛出异常
+            //        .setProgressListener((progressSize, allSize) -> log.info(
+            //                "文件 {}{}{} 迁移进度：{} {}%",
+            //                fileInfo.getBasePath(),
+            //                fileInfo.getPath(),
+            //                fileInfo.getFilename(),
+            //                progressSize,
+            //                progressSize * 100 / allSize))
+            //        .move();
+        }
+    }
+
+    /**
+     * 使用数据库迁移文件
+     */
+    @Test
+    public void transferByPlatform() {
+        // 源存储平台
+        String fromPlatform = "azure-blob-1";
+        // 目标存储平台
+        String toPlatform = "huawei-obs-1";
+        // 要迁移的路径
+        String path = "";
+        // 开始迁移
+        transfer(fromPlatform, toPlatform, path);
+    }
+
+    /**
+     * 使用数据库迁移文件
+     */
+    public void transfer(String fromPlatform, String toPlatform, String path) {
+
+        // 例举出当前路径下所有目录及文件
+        ListFilesResult result = fileStorageService
+                .listFiles()
+                .setPlatform(fromPlatform)
+                .setPath(path)
+                .listFiles();
+
+        // 递归迁移所有子目录
+        for (RemoteDirInfo dir : result.getDirList()) {
+            transfer(fromPlatform, toPlatform, path + dir.getName() + "/");
+        }
+
+        // 迁移当前路径下所有文件
+        for (RemoteFileInfo remoteFileInfo : result.getFileList()) {
+            // 转换成 FileInfo，注意 createTime 、metadata 及 userMetadata 可能需要自行处理，详情查看方法源码注释
+            // 同时每个存储平台的 ACL 也不一样，也需要自行处理
+            FileInfo fileInfo = remoteFileInfo.toFileInfo();
+
+            // 这里仅保留需要的 metadata ，例如：
+            Map<String, String> fromMetadata = new KebabCaseInsensitiveMap<>(fileInfo.getMetadata());
+            Map<String, String> toMetadata = new HashMap<>();
+            if (fromMetadata.containsKey(Constant.Metadata.CONTENT_TYPE)) {
+                toMetadata.put(Constant.Metadata.CONTENT_TYPE, fromMetadata.get(Constant.Metadata.CONTENT_TYPE));
+            }
+            if (fromMetadata.containsKey(Constant.Metadata.CONTENT_LENGTH)) {
+                toMetadata.put(Constant.Metadata.CONTENT_LENGTH, fromMetadata.get(Constant.Metadata.CONTENT_LENGTH));
+            }
+            if (fromMetadata.containsKey(Constant.Metadata.CONTENT_DISPOSITION)) {
+                toMetadata.put(
+                        Constant.Metadata.CONTENT_DISPOSITION, fromMetadata.get(Constant.Metadata.CONTENT_DISPOSITION));
+            }
+            fileInfo.setMetadata(toMetadata);
+
+            // 使用复制文件，会保留旧文件，推荐
+            fileStorageService
+                    .move(fileInfo)
+                    .setPlatform(toPlatform)
+                    .setNotSupportMetadataThrowException(true) // 不支持元数据时抛出异常
+                    .setNotSupportAclThrowException(true) // 不支持 ACL 时抛出异常
+                    .setProgressListener((progressSize, allSize) -> log.info(
+                            "文件 {}/{} 迁移进度：{} {}%",
+                            fileInfo.getPath(), fileInfo.getFilename(), progressSize, progressSize * 100 / allSize))
+                    .move();
+            // 使用移动文件，会删除旧文件，不推荐
+            // fileStorageService
+            //        .copy(fileInfo)
+            //        .setPlatform(toPlatform)
+            //        .setNotSupportMetadataThrowException(true) // 不支持元数据时抛出异常
+            //        .setNotSupportAclThrowException(true) // 不支持 ACL 时抛出异常
+            //        .setProgressListener((progressSize, allSize) -> log.info(
+            //                "文件 {}/{} 迁移进度：{} {}%",
+            //                fileInfo.getPath(), fileInfo.getFilename(), progressSize, progressSize * 100 / allSize))
+            //        .copy();
+        }
+    }
+}