添加本地上传的功能

调整Excel导出时使用的方法
2026-01-30 21:40:21 +08:00 · 2025-12-28 12:33:06 +08:00
18 changed files with 624 additions and 243 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 .cursor
+.DS_Store
--- a/README.md
+++ b/README.md
@@ -59,7 +59,7 @@
 提供从外部文件加载配置的功能，支持数据库、OSS、Redis、CORS、MinIO等配置。

 ### 6. 存储工具 (storage)
-提供文件上传和查看功能，支持OSS和MinIO两种存储方式，并提供HTTP处理器。
+提供文件上传和查看功能，支持本地文件夹（Local）、OSS 和 MinIO 三种存储方式，并提供HTTP处理器。

 ### 7. 邮件工具 (email)
 提供SMTP邮件发送功能，支持纯文本和HTML邮件，使用Go标准库实现。
@@ -105,6 +105,7 @@
 | 数据库 | `GetDatabase()` | 返回GORM对象，用于复杂查询 | ⭐⭐ |
 | Redis高级 | `GetRedisClient()` | 返回Redis客户端，用于Hash/List/Set等 | ⭐ |
 | Logger高级 | `GetLogger()` | 返回Logger对象，用于Close等 | ⭐ |
+| 存储高级 | `GetStorage()` | 返回Storage对象，用于Delete/Exists/GetObject等 | ⭐ |

 ### 使用示例

--- a/VERSION.md
+++ b/VERSION.md
@@ -129,3 +129,8 @@ go get -u=minor git.toowon.com/jimmy/go-common
  - 初始版本
  - 包含所有基础工具类：migration、datetime、http、middleware、config、storage、email、sms、factory、logger

+- **v1.1.0** (未发布)
+  - storage：新增本地文件夹存储（LocalStorage），支持将文件/图片上传到本地目录
+  - config：新增 `localStorage` 配置段（`baseDir` / `publicURL`）
+  - factory：新增 `GetStorage()`，并支持 Local/MinIO/OSS 自动选择（优先级：Local > MinIO > OSS）
+
--- a/config/config.go
+++ b/config/config.go
@@ -9,15 +9,31 @@ import (

 // Config 应用配置
 type Config struct {
-	Database  *DatabaseConfig  `json:"database"`
-	OSS       *OSSConfig       `json:"oss"`
-	Redis     *RedisConfig     `json:"redis"`
-	CORS      *CORSConfig      `json:"cors"`
-	MinIO     *MinIOConfig     `json:"minio"`
-	Email     *EmailConfig     `json:"email"`
-	SMS       *SMSConfig       `json:"sms"`
-	Logger    *LoggerConfig    `json:"logger"`
-	RateLimit *RateLimitConfig `json:"rateLimit"`
+	Database  *DatabaseConfig     `json:"database"`
+	OSS       *OSSConfig          `json:"oss"`
+	Redis     *RedisConfig        `json:"redis"`
+	CORS      *CORSConfig         `json:"cors"`
+	MinIO     *MinIOConfig        `json:"minio"`
+	Local     *LocalStorageConfig `json:"localStorage"`
+	Email     *EmailConfig        `json:"email"`
+	SMS       *SMSConfig          `json:"sms"`
+	Logger    *LoggerConfig       `json:"logger"`
+	RateLimit *RateLimitConfig    `json:"rateLimit"`
+}
+
+// LocalStorageConfig 本地存储配置
+// 用于将文件保存到本地文件夹（适合开发环境、单机部署等场景）
+type LocalStorageConfig struct {
+	// BaseDir 本地文件保存根目录（必填）
+	// 示例: "./uploads" 或 "/var/app/uploads"
+	BaseDir string `json:"baseDir"`
+
+	// PublicURL 对外访问URL（可选）
+	// 1) 若包含 "{objectKey}" 占位符，则会替换为 url.QueryEscape(objectKey)
+	//    示例: "http://localhost:8080/file?key={objectKey}" （配合 ProxyHandler 使用）
+	// 2) 若不包含占位符，则作为URL前缀，自动拼接 objectKey
+	//    示例: "http://localhost:8080/static/" => "http://localhost:8080/static/<objectKey>"
+	PublicURL string `json:"publicURL"`
 }

 // DatabaseConfig 数据库配置
@@ -439,6 +455,11 @@ func (c *Config) GetMinIO() *MinIOConfig {
 	return c.MinIO
 }

+// GetLocalStorage 获取本地存储配置
+func (c *Config) GetLocalStorage() *LocalStorageConfig {
+	return c.Local
+}
+
 // GetEmail 获取邮件配置
 func (c *Config) GetEmail() *EmailConfig {
 	return c.Email
--- a/config/example.json
+++ b/config/example.json
@@ -50,6 +50,10 @@
    "region": "us-east-1",
    "domain": "http://localhost:9000"
  },
+  "localStorage": {
+    "baseDir": "./uploads",
+    "publicURL": "http://localhost:8080/file?key={objectKey}"
+  },
  "email": {
    "host": "smtp.example.com",
    "port": 587,
--- a/docs/config.md
+++ b/docs/config.md
@@ -2,12 +2,13 @@

 ## 概述

-配置工具提供了从外部文件加载和管理应用配置的功能，支持数据库、OSS、Redis、CORS、MinIO、邮件、短信等常用服务的配置。
+配置工具提供了从外部文件加载和管理应用配置的功能，支持数据库、LocalStorage、OSS、Redis、CORS、MinIO、邮件、短信等常用服务的配置。

 ## 功能特性

 - 支持从外部JSON文件加载配置
 - 支持数据库配置（MySQL、PostgreSQL、SQLite）
+- 支持本地存储配置（LocalStorage，文件上传保存到本地文件夹）
 - 支持OSS对象存储配置（阿里云、腾讯云、AWS、七牛云等）
 - 支持Redis配置
 - 支持CORS配置（与middleware包集成）
@@ -75,6 +76,10 @@
    "region": "us-east-1",
    "domain": "http://localhost:9000"
  },
+  "localStorage": {
+    "baseDir": "./uploads",
+    "publicURL": "http://localhost:8080/file?key={objectKey}"
+  },
  "email": {
    "host": "smtp.example.com",
    "port": 587,
@@ -196,6 +201,16 @@ if minioConfig != nil {
 }
 ```

+### 6.1 获取本地存储配置（LocalStorage）
+
+```go
+localCfg := config.GetLocalStorage()
+if localCfg != nil {
+    fmt.Printf("Local baseDir: %s\n", localCfg.BaseDir)
+    fmt.Printf("Local publicURL: %s\n", localCfg.PublicURL)
+}
+```
+
 ## 配置项说明

 ### DatabaseConfig 数据库配置
@@ -266,6 +281,13 @@ if minioConfig != nil {
 | Region | string | 区域 |
 | Domain | string | 自定义域名 |

+### LocalStorageConfig 本地存储配置
+
+| 字段 | 类型 | 说明 |
+|------|------|------|
+| BaseDir | string | 本地文件保存根目录（必填） |
+| PublicURL | string | 对外访问 URL（可选）。包含 `{objectKey}` 占位符时会替换为 `url.QueryEscape(objectKey)`；不包含时作为 URL 前缀拼接 |
+
 ### EmailConfig 邮件配置

 | 字段 | 类型 | 说明 | 默认值 |
--- a/docs/excel.md
+++ b/docs/excel.md
@@ -15,29 +15,24 @@ Excel导出工具提供了将数据导出到Excel文件的功能，支持结构
 - **表头样式**：自动应用表头样式（加粗、背景色等）
 - **智能工作表管理**：自动处理工作表的创建和删除，避免产生空sheet
 - **ExportData接口**：支持实现ExportData接口进行高级定制
+- **空数据处理**：即使数据为空（nil或空切片），也会正常生成表头
+- **统一接口**：只暴露 `ExportToWriter` 一个核心方法

 ## 使用方法

-### 1. 创建工厂（推荐）
+### 1. 创建工厂

 ```go
 import "git.toowon.com/jimmy/go-common/factory"

-// 方式1：从配置文件创建（推荐）
+// 从配置文件创建
 fac, err := factory.NewFactoryFromFile("./config.json")
-if err != nil {
-    log.Fatal(err)
-}

-// 方式2：从配置对象创建
-cfg, _ := config.LoadFromFile("./config.json")
-fac := factory.NewFactory(cfg)
-
-// 方式3：Excel导出不需要配置，可以传nil
+// 或Excel导出不需要配置，可以传nil
 fac := factory.NewFactory(nil)
 ```

-### 2. 导出结构体切片到文件（黑盒模式，推荐）
+### 2. 导出结构体切片到文件

 ```go
 // 定义结构体
@@ -71,7 +66,7 @@ if err != nil {
 }
 ```

-### 3. 导出到HTTP响应（黑盒模式，推荐）
+### 3. 导出到HTTP响应

 ```go
 import "net/http"
@@ -103,7 +98,7 @@ func exportUsersHandler(w http.ResponseWriter, r *http.Request) {
 }
 ```

-### 4. 使用格式化函数（黑盒模式，推荐）
+### 4. 使用格式化函数

 ```go
 import "git.toowon.com/jimmy/go-common/excel"
@@ -202,7 +197,7 @@ file.SetCellStyle("Sheet2", "A1", "A1", style)

 ## API 参考

-### 工厂方法（黑盒模式，推荐使用）
+### 工厂方法

 #### ExportToExcel(w io.Writer, sheetName string, columns []ExportColumn, data interface{}) error

@@ -216,19 +211,19 @@ file.SetCellStyle("Sheet2", "A1", "A1", style)

 **返回：** 错误信息

+**数据为空处理：**
+- 支持 `nil`、空切片、指针类型等空数据情况
+- 即使数据为空，表头也会正常生成
+
 **工作表处理逻辑：**
- 如果 `sheetName` 为空或未指定，默认使用 "Sheet1"
- 如果指定的工作表已存在，直接使用该工作表
- 如果指定的工作表不存在，会自动创建新工作表
- 如果使用自定义名称（非"Sheet1"），会自动删除默认的"Sheet1"工作表，避免产生空sheet
+- 如果 `sheetName` 为空，默认使用 "Sheet1"
+- 如果指定的工作表不存在，会自动创建
+- 使用自定义名称时会自动删除默认的"Sheet1"，避免产生空sheet

 **示例：**
 ```go
-// 使用默认Sheet1
-fac.ExportToExcel(w, "", columns, users)
-
-// 使用自定义工作表名称
 fac.ExportToExcel(w, "用户列表", columns, users)
+fac.ExportToExcel(w, "空数据", columns, []User{}) // 空数据也会生成表头
 ```

 #### ExportToExcelFile(filePath string, sheetName string, columns []ExportColumn, data interface{}) error
@@ -239,23 +234,23 @@ fac.ExportToExcel(w, "用户列表", columns, users)
 - `filePath`: 文件路径
 - `sheetName`: 工作表名称（可选，默认为"Sheet1"）
 - `columns`: 列定义
- `data`: 数据列表
+- `data`: 数据列表（可以是结构体切片或实现了ExportData接口的对象）

 **返回：** 错误信息

+**实现说明：**
+- 此方法内部创建文件并调用 `ExportToWriter`
+- 文件相关的封装由工厂方法处理
+
 **工作表处理逻辑：**
- 如果 `sheetName` 为空或未指定，默认使用 "Sheet1"
- 如果指定的工作表已存在，直接使用该工作表
- 如果指定的工作表不存在，会自动创建新工作表
- 如果使用自定义名称（非"Sheet1"），会自动删除默认的"Sheet1"工作表，避免产生空sheet
+- 如果 `sheetName` 为空，默认使用 "Sheet1"
+- 如果指定的工作表不存在，会自动创建
+- 使用自定义名称时会自动删除默认的"Sheet1"，避免产生空sheet

 **示例：**
 ```go
-// 使用默认Sheet1
-fac.ExportToExcelFile("users.xlsx", "", columns, users)
-
-// 使用自定义工作表名称
 fac.ExportToExcelFile("users.xlsx", "用户列表", columns, users)
+fac.ExportToExcelFile("empty.xlsx", "空数据", columns, []User{}) // 空数据也会生成表头
 ```

 ### 高级方法
@@ -266,9 +261,7 @@ fac.ExportToExcelFile("users.xlsx", "用户列表", columns, users)

 **返回：** Excel导出器对象和错误信息

-**说明：** 
- 仅在需要使用高级功能时使用
- 推荐使用黑盒方法：`ExportToExcel()`、`ExportToExcelFile()`
+**说明：** 仅在需要使用高级功能时使用，推荐使用黑盒方法

 ### 结构体类型

@@ -304,8 +297,6 @@ type ExportColumn struct {

 **说明：** 
 - 允许直接使用tools包的任何格式化函数
- 推荐使用此适配器，避免重复实现格式化逻辑
- 与factory中的FormatDateTime等方法保持一致

 **示例：**
 ```go
@@ -419,39 +410,36 @@ func main() {

 ## 设计优势

-### 优势总结
-
 1. **降低复杂度**：调用方无需关心Excel文件对象的创建和管理
-2. **延迟初始化**：Excel导出器在首次使用时才创建，提高性能
-3. **统一接口**：所有操作通过工厂方法调用，接口统一
+2. **延迟初始化**：Excel导出器在首次使用时才创建
+3. **统一接口**：所有操作通过工厂方法调用
 4. **灵活扩展**：支持结构体切片、自定义格式化、ExportData接口等多种方式
 5. **自动优化**：自动调整列宽、应用表头样式等

 ## 注意事项

-1. **配置检查**：Excel导出不需要配置，可以传nil创建工厂
+1. **配置**：Excel导出不需要配置，可以传nil创建工厂
 2. **错误处理**：所有方法都可能返回错误，需要正确处理
 3. **延迟初始化**：Excel导出器在首次使用时才创建，首次调用可能稍慢
 4. **字段名匹配**：Field字段名必须与结构体字段名匹配（区分大小写）
 5. **嵌套字段**：支持嵌套字段访问（如 "User.Name"），但需要确保字段路径正确
 6. **格式化函数**：格式化函数返回的字符串会直接写入Excel单元格
 7. **列宽设置**：Width为0时会自动调整列宽，但可能影响性能（大数据量时建议设置固定宽度）
-8. **工作表处理**：
-   - 使用默认"Sheet1"时，会直接使用默认工作表，不会产生空sheet
-   - 使用自定义工作表名称时，会自动删除默认的"Sheet1"，确保文件只有一个工作表
-   - 如果指定的工作表已存在，会直接使用，不会重复创建
+8. **工作表处理**：工具会自动处理工作表的创建和删除，确保不会产生空sheet
+9. **空数据处理**：即使数据为 `nil` 或空切片，表头也会正常生成
+10. **方法设计**：
+    - `excel` 包只暴露 `ExportToWriter` 一个核心方法
+    - 文件相关的封装由工厂方法 `ExportToExcelFile` 处理

 ## 最佳实践

-1. **使用黑盒方法**：推荐使用 `ExportToExcel()` 和 `ExportToExcelFile()`，无需获取Excel对象
+1. **使用工厂方法**：推荐使用 `ExportToExcel()` 和 `ExportToExcelFile()`
 2. **设置列宽**：对于大数据量，建议设置固定列宽以提高性能
 3. **使用格式化函数**：对于日期时间、状态等字段，使用格式化函数提高可读性
 4. **错误处理**：始终检查导出方法的返回值
 5. **HTTP响应**：导出到HTTP响应时，记得设置正确的Content-Type和Content-Disposition头
-6. **工作表命名**：
-   - 推荐使用有意义的工作表名称（如"用户列表"、"订单数据"等），提高可读性
-   - 如果不指定工作表名称，会使用默认的"Sheet1"
-   - 工具会自动处理工作表的创建和删除，确保不会产生空sheet
+6. **工作表命名**：推荐使用有意义的工作表名称，工具会自动处理工作表的创建和删除
+7. **空数据场景**：即使查询结果为空，也可以导出包含表头的Excel文件

 ## 示例

--- a/docs/storage.md
+++ b/docs/storage.md
@@ -2,10 +2,11 @@

 ## 概述

-存储工具提供了文件上传和查看功能，支持OSS和MinIO两种存储方式，并提供HTTP处理器用于文件上传和代理查看。
+存储工具提供了文件上传和查看功能，支持 **本地文件夹(Local)**、OSS 和 MinIO 三种存储方式，并提供HTTP处理器用于文件上传和代理查看。

 ## 功能特性

+- 支持本地文件夹存储（Local）
 - 支持OSS对象存储（阿里云、腾讯云、AWS、七牛云等）
 - 支持MinIO对象存储
 - 提供统一的存储接口
@@ -17,6 +18,32 @@

 ## 使用方法

+### 0. 工厂调用方式（推荐）
+
+当你使用 `factory` 黑盒模式时，外部项目无需关心底层是 Local/MinIO/OSS：
+
+```go
+import (
+    "context"
+    "os"
+
+    "git.toowon.com/jimmy/go-common/factory"
+    "git.toowon.com/jimmy/go-common/storage"
+)
+
+fac, _ := factory.NewFactoryFromFile("./config.json")
+
+f, _ := os.Open("test.jpg")
+defer f.Close()
+
+objectKey := storage.GenerateObjectKeyWithDate("uploads/images", "test.jpg")
+url, err := fac.UploadFile(context.Background(), objectKey, f, "image/jpeg")
+if err != nil {
+    panic(err)
+}
+_ = url
+```
+
 ### 1. 创建存储实例

 ```go
@@ -42,6 +69,12 @@ minioStorage, err := storage.NewStorage(storage.StorageTypeMinIO, cfg)
 if err != nil {
    log.Fatal(err)
 }
+
+// 创建本地存储实例
+localStorage, err := storage.NewStorage(storage.StorageTypeLocal, cfg)
+if err != nil {
+    log.Fatal(err)
+}
 ```

 ### 2. 上传文件
@@ -76,6 +109,25 @@ if err != nil {
 fmt.Printf("File URL: %s\n", url)
 ```

+### 2.1 本地存储配置示例
+
+`config.json` 增加 `localStorage` 配置段：
+
+```json
+{
+  "localStorage": {
+    "baseDir": "./uploads",
+    "publicURL": "http://localhost:8080/file?key={objectKey}"
+  }
+}
+```
+
+说明：
+- **baseDir**：文件保存根目录
+- **publicURL**：用于 `GetURL()` 返回对外可访问的 URL
+  - 推荐配合本文的 `ProxyHandler`，示例 `http://localhost:8080/file?key={objectKey}`
+  - `{objectKey}` 会自动做 `url.QueryEscape` 处理
+
 ### 3. 使用HTTP处理器上传文件

 ```go
@@ -136,6 +188,10 @@ http.Handle("/file", proxyHandler)
 http.ListenAndServe(":8080", nil)
 ```

+**本地存储建议搭配：**
+- `POST /upload` 上传文件（返回 `url`）
+- `GET /file?key=...` 通过代理读取本地文件并返回二进制内容
+
 **查看请求示例：**
 ```
 GET /file?key=images/test.jpg
--- a/examples/config_example.go
+++ b/examples/config_example.go
@@ -1,3 +1,6 @@
+//go:build example
+// +build example
+
 package main

 import (
--- a/examples/doc.go
+++ b/examples/doc.go
@@ -0,0 +1,8 @@
+// Package examples contains build-tagged example programs.
+//
+// 所有示例程序默认不参与 `go test ./...` 编译，避免多个 main 冲突。
+//
+// 运行示例：
+//   go run -tags example ./examples/storage_example.go
+package examples
+
--- a/examples/email_example.go
+++ b/examples/email_example.go
@@ -1,3 +1,6 @@
+//go:build example
+// +build example
+
 package main

 import (
--- a/examples/excel_example.go
+++ b/examples/excel_example.go
@@ -1,3 +1,6 @@
+//go:build example
+// +build example
+
 package main

 import (
--- a/examples/storage_example.go
+++ b/examples/storage_example.go
@@ -1,3 +1,6 @@
+//go:build example
+// +build example
+
 package main

 import (
@@ -16,52 +19,51 @@ func main() {
 		log.Fatal("Failed to load config:", err)
 	}

-	// 创建存储实例（使用OSS）
-	// 注意：需要先实现OSS SDK集成
-	ossStorage, err := storage.NewStorage(storage.StorageTypeOSS, cfg)
+	// 优先演示本地存储（可直接运行）
+	localStorage, err := storage.NewStorage(storage.StorageTypeLocal, cfg)
 	if err != nil {
-		log.Printf("Failed to create OSS storage: %v", err)
-		log.Println("Note: OSS SDK integration is required")
-		// 继续演示其他功能
-	} else {
-		// 创建上传处理器
-		uploadHandler := storage.NewUploadHandler(storage.UploadHandlerConfig{
-			Storage:      ossStorage,
-			MaxFileSize:  10 * 1024 * 1024, // 10MB
-			AllowedExts:  []string{".jpg", ".jpeg", ".png", ".gif", ".pdf"},
-			ObjectPrefix: "uploads/",
-		})
+		log.Fatal("Failed to create Local storage:", err)
+	}

-		// 创建代理查看处理器
-		proxyHandler := storage.NewProxyHandler(ossStorage)
+	uploadHandler := storage.NewUploadHandler(storage.UploadHandlerConfig{
+		Storage:      localStorage,
+		MaxFileSize:  10 * 1024 * 1024, // 10MB
+		AllowedExts:  []string{".jpg", ".jpeg", ".png", ".gif", ".pdf"},
+		ObjectPrefix: "uploads/",
+	})

-		// 创建中间件链
-		var corsConfig *middleware.CORSConfig
-		if cfg.GetCORS() != nil {
-			c := cfg.GetCORS()
-			corsConfig = middleware.NewCORSConfig(
-				c.AllowedOrigins,
-				c.AllowedMethods,
-				c.AllowedHeaders,
-				c.ExposedHeaders,
-				c.AllowCredentials,
-				c.MaxAge,
-			)
-		}
-		chain := middleware.NewChain(
-			middleware.CORS(corsConfig),
-			middleware.Timezone,
+	proxyHandler := storage.NewProxyHandler(localStorage)
+
+	// 创建中间件链
+	var corsConfig *middleware.CORSConfig
+	if cfg.GetCORS() != nil {
+		c := cfg.GetCORS()
+		corsConfig = middleware.NewCORSConfig(
+			c.AllowedOrigins,
+			c.AllowedMethods,
+			c.AllowedHeaders,
+			c.ExposedHeaders,
+			c.AllowCredentials,
+			c.MaxAge,
 		)
+	}
+	chain := middleware.NewChain(
+		middleware.CORS(corsConfig),
+		middleware.Timezone,
+	)

-		// 注册路由
-		mux := http.NewServeMux()
-		mux.Handle("/upload", chain.Then(uploadHandler))
-		mux.Handle("/file", chain.Then(proxyHandler))
+	// 注册路由
+	mux := http.NewServeMux()
+	mux.Handle("/upload", chain.Then(uploadHandler))
+	mux.Handle("/file", chain.Then(proxyHandler))

-		log.Println("Storage server started on :8080")
-		log.Println("Upload: POST /upload")
-		log.Println("View: GET /file?key=images/test.jpg")
-		log.Fatal(http.ListenAndServe(":8080", mux))
+	log.Println("Local storage server started on :8080")
+	log.Println("Upload: POST /upload")
+	log.Println("View: GET /file?key=uploads/xxx.jpg")
+
+	// 提示：OSS 需要你自行集成对应 SDK（当前 go-common 中仅提供接口框架）
+	if _, err := storage.NewStorage(storage.StorageTypeOSS, cfg); err != nil {
+		log.Printf("OSS storage not ready: %v", err)
 	}

 	// 演示MinIO存储
@@ -79,5 +81,6 @@ func main() {

 	objectKey2 := storage.GenerateObjectKeyWithDate("images", "test.jpg")
 	log.Printf("Object key 2: %s", objectKey2)
-}

+	log.Fatal(http.ListenAndServe(":8080", mux))
+}
--- a/excel/excel.go
+++ b/excel/excel.go
@@ -163,12 +163,20 @@ func (e *Excel) ExportToWriter(w io.Writer, sheetName string, columns []ExportCo
 	if exportData, ok := data.(ExportData); ok {
 		// 使用接口方法获取数据
 		rows = exportData.GetExportRows()
+		// 如果接口返回nil，初始化为空切片
+		if rows == nil {
+			rows = [][]interface{}{}
+		}
 	} else {
-		// 处理结构体切片
+		// 处理结构体切片（包括nil和空切片的情况）
 		rows, err = e.convertDataToRows(data, columns)
 		if err != nil {
 			return fmt.Errorf("failed to convert data to rows: %w", err)
 		}
+		// 确保rows不为nil
+		if rows == nil {
+			rows = [][]interface{}{}
+		}
 	}

 	// 写入数据行
@@ -202,140 +210,11 @@ func (e *Excel) ExportToWriter(w io.Writer, sheetName string, columns []ExportCo
 	return e.file.Write(w)
 }

-// ExportToFile 导出数据到文件（黑盒模式，推荐使用）
-// filePath: 文件路径
-// sheetName: 工作表名称（可选，默认为"Sheet1"）
-// columns: 列定义
-// data: 数据列表
-// 返回错误信息
-//
-// 示例：
-//
-//	excel := excel.NewExcel()
-//	err := excel.ExportToFile("users.xlsx", "用户列表", columns, users)
-func (e *Excel) ExportToFile(filePath string, sheetName string, columns []ExportColumn, data interface{}) error {
-	if e.file == nil {
-		e.file = excelize.NewFile()
-	}
-
-	// 设置工作表名称
-	if sheetName == "" {
-		sheetName = "Sheet1"
-	}
-
-	// 检查工作表是否已存在
-	sheetIndex, err := e.file.GetSheetIndex(sheetName)
-	if err != nil || sheetIndex == 0 {
-		// 工作表不存在，需要创建
-		// 如果sheetName不是"Sheet1"，且默认"Sheet1"存在，则删除它
-		if sheetName != "Sheet1" {
-			defaultIndex, _ := e.file.GetSheetIndex("Sheet1")
-			if defaultIndex > 0 {
-				e.file.DeleteSheet("Sheet1")
-			}
-		}
-
-		// 创建新工作表
-		_, err = e.file.NewSheet(sheetName)
-		if err != nil {
-			return fmt.Errorf("failed to create sheet: %w", err)
-		}
-
-		// 重新获取工作表索引
-		sheetIndex, err = e.file.GetSheetIndex(sheetName)
-		if err != nil {
-			return fmt.Errorf("failed to get sheet index: %w", err)
-		}
-	}
-
-	// 设置活动工作表
-	if sheetIndex > 0 {
-		e.file.SetActiveSheet(sheetIndex)
-	}
-
-	// 写入表头
-	headerStyle, _ := e.file.NewStyle(&excelize.Style{
-		Font: &excelize.Font{
-			Bold: true,
-			Size: 12,
-		},
-		Fill: excelize.Fill{
-			Type:    "pattern",
-			Color:   []string{"#E0E0E0"},
-			Pattern: 1,
-		},
-		Alignment: &excelize.Alignment{
-			Horizontal: "center",
-			Vertical:   "center",
-		},
-	})
-
-	for i, col := range columns {
-		cell := fmt.Sprintf("%c1", 'A'+i)
-		e.file.SetCellValue(sheetName, cell, col.Header)
-
-		// 设置表头样式
-		e.file.SetCellStyle(sheetName, cell, cell, headerStyle)
-
-		// 设置列宽
-		if col.Width > 0 {
-			colName, _ := excelize.ColumnNumberToName(i + 1)
-			e.file.SetColWidth(sheetName, colName, colName, col.Width)
-		}
-	}
-
-	// 处理数据
-	var rows [][]interface{}
-
-	// 检查数据是否实现了ExportData接口
-	if exportData, ok := data.(ExportData); ok {
-		// 使用接口方法获取数据
-		rows = exportData.GetExportRows()
-	} else {
-		// 处理结构体切片
-		rows, err = e.convertDataToRows(data, columns)
-		if err != nil {
-			return fmt.Errorf("failed to convert data to rows: %w", err)
-		}
-	}
-
-	// 写入数据行
-	for rowIndex, row := range rows {
-		for colIndex, value := range row {
-			cell := fmt.Sprintf("%c%d", 'A'+colIndex, rowIndex+2) // +2 因为第一行是表头
-
-			// 应用格式化函数
-			var cellValue interface{} = value
-			if colIndex < len(columns) && columns[colIndex].Format != nil {
-				cellValue = columns[colIndex].Format(value)
-			}
-
-			e.file.SetCellValue(sheetName, cell, cellValue)
-		}
-	}
-
-	// 自动调整列宽（如果未设置宽度）
-	for i, col := range columns {
-		if col.Width == 0 {
-			colName, _ := excelize.ColumnNumberToName(i + 1)
-			// 获取列的最大宽度
-			maxWidth := e.getColumnMaxWidth(sheetName, i+1, len(rows)+1)
-			if maxWidth > 0 {
-				e.file.SetColWidth(sheetName, colName, colName, maxWidth)
-			}
-		}
-	}
-
-	// 保存文件
-	return e.file.SaveAs(filePath)
-}
-
 // GetFile 获取Excel文件对象（高级功能时使用）
 // 返回excelize.File对象，可用于高级操作
 //
 // ℹ️  推荐使用黑盒方法：
-//   - ExportToWriter()：导出到Writer
-//   - ExportToFile()：导出到文件
+//   - ExportToWriter()：导出到Writer（可用于文件、HTTP响应等）
 //
 // 仅在需要使用高级功能时获取对象：
 //   - 多工作表操作
@@ -345,7 +224,9 @@ func (e *Excel) ExportToFile(filePath string, sheetName string, columns []Export
 // 示例（常用操作，推荐）：
 //
 //	excel := excel.NewExcel()
-//	excel.ExportToFile("users.xlsx", "用户列表", columns, users)
+//	file, _ := os.Create("users.xlsx")
+//	defer file.Close()
+//	excel.ExportToWriter(file, "用户列表", columns, users)
 //
 // 示例（高级功能）：
 //
@@ -360,15 +241,36 @@ func (e *Excel) GetFile() *excelize.File {
 }

 // convertDataToRows 将数据转换为行数据
+// 支持nil、空切片等情况，返回空切片而不是错误
 func (e *Excel) convertDataToRows(data interface{}, columns []ExportColumn) ([][]interface{}, error) {
+	// 如果data为nil，返回空切片
+	if data == nil {
+		return [][]interface{}{}, nil
+	}
+
 	// 使用反射处理数据
 	val := reflect.ValueOf(data)
 	if val.Kind() == reflect.Ptr {
+		// 如果是指针且指向nil，返回空切片
+		if val.IsNil() {
+			return [][]interface{}{}, nil
+		}
 		val = val.Elem()
 	}

+	// 如果解引用后仍然是无效值，返回空切片
+	if !val.IsValid() {
+		return [][]interface{}{}, nil
+	}
+
+	// 必须是切片类型
 	if val.Kind() != reflect.Slice {
-		return nil, fmt.Errorf("data must be a slice")
+		return nil, fmt.Errorf("data must be a slice, got %v", val.Kind())
+	}
+
+	// 如果是空切片，返回空切片（不返回错误）
+	if val.Len() == 0 {
+		return [][]interface{}{}, nil
 	}

 	rows := make([][]interface{}, 0, val.Len())
@@ -376,6 +278,12 @@ func (e *Excel) convertDataToRows(data interface{}, columns []ExportColumn) ([][
 	for i := 0; i < val.Len(); i++ {
 		item := val.Index(i)
 		if item.Kind() == reflect.Ptr {
+			// 如果指针指向nil，跳过该行或使用空值
+			if item.IsNil() {
+				row := make([]interface{}, len(columns))
+				rows = append(rows, row)
+				continue
+			}
 			item = item.Elem()
 		}

--- a/factory/factory.go
+++ b/factory/factory.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"os"
 	"strings"
 	"time"

@@ -652,14 +653,16 @@ func (f *Factory) getStorage() (storage.Storage, error) {
 	}

 	// 根据配置自动选择存储类型
-	// 优先级：MinIO > OSS
+	// 优先级：Local > MinIO > OSS
 	var storageType storage.StorageType
-	if f.cfg.MinIO != nil {
+	if f.cfg.GetLocalStorage() != nil {
+		storageType = storage.StorageTypeLocal
+	} else if f.cfg.MinIO != nil {
 		storageType = storage.StorageTypeMinIO
 	} else if f.cfg.OSS != nil {
 		storageType = storage.StorageTypeOSS
 	} else {
-		return nil, fmt.Errorf("no storage config found (OSS or MinIO)")
+		return nil, fmt.Errorf("no storage config found (LocalStorage, OSS or MinIO)")
 	}

 	// 创建存储实例
@@ -672,6 +675,16 @@ func (f *Factory) getStorage() (storage.Storage, error) {
 	return s, nil
 }

+// GetStorage 获取存储实例对象（高级功能时使用）
+// 通常推荐使用黑盒方法：
+//   - UploadFile()
+//   - GetFileURL()
+//
+// 如需自定义上传/查看行为（例如 Delete/Exists/GetObject），可使用此方法获取底层存储对象。
+func (f *Factory) GetStorage() (storage.Storage, error) {
+	return f.getStorage()
+}
+
 // UploadFile 上传文件（黑盒模式，推荐使用）
 // 自动根据配置选择存储类型（OSS 或 MinIO），无需关心内部实现
 // ctx: 上下文
@@ -1648,16 +1661,27 @@ func (f *Factory) ExportToExcel(w io.Writer, sheetName string, columns []ExportC
 // filePath: 文件路径
 // sheetName: 工作表名称（可选，默认为"Sheet1"）
 // columns: 列定义
-// data: 数据列表
+// data: 数据列表（可以是结构体切片或实现了ExportData接口的对象）
 // 返回错误信息
 //
 // 示例：
 //
 //	fac.ExportToExcelFile("users.xlsx", "用户列表", columns, users)
+//
+// 注意：此方法内部创建文件并调用 ExportToWriter，确保行为与 ExportToExcel 一致
 func (f *Factory) ExportToExcelFile(filePath string, sheetName string, columns []ExportColumn, data interface{}) error {
 	e, err := f.getExcelClient()
 	if err != nil {
 		return err
 	}
-	return e.ExportToFile(filePath, sheetName, columns, data)
+
+	// 创建文件
+	file, err := os.Create(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to create file: %w", err)
+	}
+	defer file.Close()
+
+	// 调用 ExportToWriter，复用核心逻辑
+	return e.ExportToWriter(file, sheetName, columns, data)
 }
--- a/storage/local.go
+++ b/storage/local.go
@@ -0,0 +1,222 @@
+package storage
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+
+	"git.toowon.com/jimmy/go-common/config"
+)
+
+// LocalStorage 本地存储实现
+// 将对象写入本地文件夹（BaseDir），对象键 objectKey 作为相对路径使用。
+//
+// 典型用法：
+//   - 上传：Upload(ctx, "uploads/2026/01/01/a.png", reader)
+//   - 查看：配合 ProxyHandler 或 http.FileServer 对外提供访问
+type LocalStorage struct {
+	baseDir   string
+	publicURL string
+}
+
+// NewLocalStorage 创建本地存储实例
+func NewLocalStorage(cfg *config.LocalStorageConfig) (*LocalStorage, error) {
+	if cfg == nil {
+		return nil, fmt.Errorf("LocalStorage config is nil")
+	}
+	if strings.TrimSpace(cfg.BaseDir) == "" {
+		return nil, fmt.Errorf("LocalStorage baseDir is empty")
+	}
+
+	absBase, err := filepath.Abs(cfg.BaseDir)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get absolute baseDir: %w", err)
+	}
+
+	// 确保根目录存在
+	if err := os.MkdirAll(absBase, 0o755); err != nil {
+		return nil, fmt.Errorf("failed to create baseDir: %w", err)
+	}
+
+	return &LocalStorage{
+		baseDir:   absBase,
+		publicURL: strings.TrimSpace(cfg.PublicURL),
+	}, nil
+}
+
+// Upload 上传文件到本地文件夹
+func (s *LocalStorage) Upload(ctx context.Context, objectKey string, reader io.Reader, contentType ...string) error {
+	_ = ctx
+	_ = contentType // 本地写文件不依赖 contentType；可由上层自行记录
+
+	dstPath, err := s.resolvePath(objectKey)
+	if err != nil {
+		return err
+	}
+
+	// 确保目录存在
+	if err := os.MkdirAll(filepath.Dir(dstPath), 0o755); err != nil {
+		return fmt.Errorf("failed to create directory: %w", err)
+	}
+
+	// 原子写入：先写临时文件，再 rename
+	tmp, err := os.CreateTemp(filepath.Dir(dstPath), ".upload-*")
+	if err != nil {
+		return fmt.Errorf("failed to create temp file: %w", err)
+	}
+
+	tmpName := tmp.Name()
+	defer func() {
+		_ = tmp.Close()
+		_ = os.Remove(tmpName)
+	}()
+
+	if _, err := io.Copy(tmp, reader); err != nil {
+		return fmt.Errorf("failed to write temp file: %w", err)
+	}
+	if err := tmp.Close(); err != nil {
+		return fmt.Errorf("failed to close temp file: %w", err)
+	}
+
+	// 如果目标文件已存在，先删除（保证跨平台兼容 rename 行为）
+	_ = os.Remove(dstPath)
+
+	if err := os.Rename(tmpName, dstPath); err != nil {
+		return fmt.Errorf("failed to move temp file to destination: %w", err)
+	}
+
+	return nil
+}
+
+// GetURL 获取本地文件访问URL
+// - 若配置了 publicURL：
+//   - 包含 "{objectKey}" 占位符：替换为 url.QueryEscape(objectKey)
+//   - 否则认为是 URL 前缀：自动拼接 objectKey（用 path.Join 处理斜杠）
+//
+// - 未配置 publicURL：返回 objectKey（相对路径）
+func (s *LocalStorage) GetURL(objectKey string, expires int64) (string, error) {
+	_ = expires // 本地存储不提供签名URL，忽略 expires
+
+	cleanKey, err := normalizeObjectKey(objectKey)
+	if err != nil {
+		return "", err
+	}
+
+	if s.publicURL == "" {
+		return cleanKey, nil
+	}
+
+	if strings.Contains(s.publicURL, "{objectKey}") {
+		return strings.ReplaceAll(s.publicURL, "{objectKey}", url.QueryEscape(cleanKey)), nil
+	}
+
+	// 作为前缀拼接
+	trimmed := strings.TrimRight(s.publicURL, "/")
+	return trimmed + "/" + path.Clean("/" + cleanKey)[1:], nil
+}
+
+// Delete 删除本地文件
+func (s *LocalStorage) Delete(ctx context.Context, objectKey string) error {
+	_ = ctx
+
+	dstPath, err := s.resolvePath(objectKey)
+	if err != nil {
+		return err
+	}
+
+	if err := os.Remove(dstPath); err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return fmt.Errorf("failed to delete file: %w", err)
+	}
+	return nil
+}
+
+// Exists 检查本地文件是否存在
+func (s *LocalStorage) Exists(ctx context.Context, objectKey string) (bool, error) {
+	_ = ctx
+
+	dstPath, err := s.resolvePath(objectKey)
+	if err != nil {
+		return false, err
+	}
+
+	info, err := os.Stat(dstPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("failed to stat file: %w", err)
+	}
+	if info.IsDir() {
+		return false, nil
+	}
+	return true, nil
+}
+
+// GetObject 获取本地文件内容
+func (s *LocalStorage) GetObject(ctx context.Context, objectKey string) (io.ReadCloser, error) {
+	_ = ctx
+
+	dstPath, err := s.resolvePath(objectKey)
+	if err != nil {
+		return nil, err
+	}
+
+	f, err := os.Open(dstPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open file: %w", err)
+	}
+	return f, nil
+}
+
+func (s *LocalStorage) resolvePath(objectKey string) (string, error) {
+	cleanKey, err := normalizeObjectKey(objectKey)
+	if err != nil {
+		return "", err
+	}
+	// 将 URL 风格路径转换为 OS 路径
+	full := filepath.Join(s.baseDir, filepath.FromSlash(cleanKey))
+
+	// 防御：确保仍在 baseDir 下
+	rel, err := filepath.Rel(s.baseDir, full)
+	if err != nil {
+		return "", fmt.Errorf("failed to resolve path: %w", err)
+	}
+	if rel == "." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) || rel == ".." {
+		return "", fmt.Errorf("invalid objectKey: %s", objectKey)
+	}
+
+	return full, nil
+}
+
+func normalizeObjectKey(objectKey string) (string, error) {
+	key := strings.TrimSpace(objectKey)
+	if key == "" {
+		return "", fmt.Errorf("objectKey is empty")
+	}
+
+	// 兼容 Windows 风格路径，统一为 URL 风格
+	key = strings.ReplaceAll(key, "\\", "/")
+
+	// 清洗路径，去除多余的 . / ..
+	// 加前缀 "/" 让 Clean 以绝对路径方式处理，避免出现空结果
+	clean := path.Clean("/" + key)
+	clean = strings.TrimPrefix(clean, "/")
+	if clean == "" || clean == "." {
+		return "", fmt.Errorf("invalid objectKey: %s", objectKey)
+	}
+
+	// 不允许以 "/" 结尾（必须指向文件）
+	if strings.HasSuffix(clean, "/") {
+		return "", fmt.Errorf("objectKey cannot be a directory: %s", objectKey)
+	}
+
+	return clean, nil
+}
--- a/storage/local_test.go
+++ b/storage/local_test.go
@@ -0,0 +1,102 @@
+package storage
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"testing"
+
+	"git.toowon.com/jimmy/go-common/config"
+)
+
+func TestLocalStorage_UploadGetExistsDelete(t *testing.T) {
+	t.Parallel()
+
+	cfg := &config.LocalStorageConfig{
+		BaseDir:   t.TempDir(),
+		PublicURL: "http://localhost:8080/file?key={objectKey}",
+	}
+	s, err := NewLocalStorage(cfg)
+	if err != nil {
+		t.Fatalf("NewLocalStorage error: %v", err)
+	}
+
+	ctx := context.Background()
+	objectKey := "uploads/2026/01/30/hello.txt"
+	body := []byte("hello local storage")
+
+	if err := s.Upload(ctx, objectKey, bytes.NewReader(body), "text/plain"); err != nil {
+		t.Fatalf("Upload error: %v", err)
+	}
+
+	exists, err := s.Exists(ctx, objectKey)
+	if err != nil {
+		t.Fatalf("Exists error: %v", err)
+	}
+	if !exists {
+		t.Fatalf("expected exists=true")
+	}
+
+	rc, err := s.GetObject(ctx, objectKey)
+	if err != nil {
+		t.Fatalf("GetObject error: %v", err)
+	}
+	defer rc.Close()
+
+	got, err := io.ReadAll(rc)
+	if err != nil {
+		t.Fatalf("ReadAll error: %v", err)
+	}
+	if !bytes.Equal(got, body) {
+		t.Fatalf("content mismatch: got=%q want=%q", string(got), string(body))
+	}
+
+	u, err := s.GetURL(objectKey, 0)
+	if err != nil {
+		t.Fatalf("GetURL error: %v", err)
+	}
+	if u == "" {
+		t.Fatalf("expected non-empty url")
+	}
+
+	if err := s.Delete(ctx, objectKey); err != nil {
+		t.Fatalf("Delete error: %v", err)
+	}
+
+	exists, err = s.Exists(ctx, objectKey)
+	if err != nil {
+		t.Fatalf("Exists error: %v", err)
+	}
+	if exists {
+		t.Fatalf("expected exists=false after delete")
+	}
+}
+
+func TestNormalizeObjectKey(t *testing.T) {
+	t.Parallel()
+
+	if _, err := normalizeObjectKey(""); err == nil {
+		t.Fatalf("expected error for empty objectKey")
+	}
+	if _, err := normalizeObjectKey("   "); err == nil {
+		t.Fatalf("expected error for blank objectKey")
+	}
+	if _, err := normalizeObjectKey("."); err == nil {
+		t.Fatalf("expected error for '.'")
+	}
+	clean1, err := normalizeObjectKey("a/b/")
+	if err != nil {
+		t.Fatalf("normalizeObjectKey error: %v", err)
+	}
+	if clean1 != "a/b" {
+		t.Fatalf("unexpected clean key: %q", clean1)
+	}
+
+	clean, err := normalizeObjectKey(`\a\..\b\c.txt`)
+	if err != nil {
+		t.Fatalf("normalizeObjectKey error: %v", err)
+	}
+	if clean != "b/c.txt" {
+		t.Fatalf("unexpected clean key: %q", clean)
+	}
+}
--- a/storage/storage.go
+++ b/storage/storage.go
@@ -39,10 +39,11 @@ type StorageType string
 const (
 	StorageTypeOSS   StorageType = "oss"
 	StorageTypeMinIO StorageType = "minio"
+	StorageTypeLocal StorageType = "local"
 )

 // NewStorage 创建存储实例
-// storageType: 存储类型（oss或minio）
+// storageType: 存储类型（oss/minio/local）
 // cfg: 配置对象
 func NewStorage(storageType StorageType, cfg *config.Config) (Storage, error) {
 	switch storageType {
@@ -58,6 +59,12 @@ func NewStorage(storageType StorageType, cfg *config.Config) (Storage, error) {
 			return nil, fmt.Errorf("MinIO config is nil")
 		}
 		return NewMinIOStorage(minioConfig)
+	case StorageTypeLocal:
+		localCfg := cfg.GetLocalStorage()
+		if localCfg == nil {
+			return nil, fmt.Errorf("LocalStorage config is nil")
+		}
+		return NewLocalStorage(localCfg)
 	default:
 		return nil, fmt.Errorf("unsupported storage type: %s", storageType)
 	}
Author	SHA1	Message	Date
Jimmy Xue	a6e8101e09	添加本地上传的功能	2026-01-30 21:40:21 +08:00
Jimmy Xue	38ebe73e45	调整Excel导出时使用的方法	2025-12-28 12:33:06 +08:00