Golang实现短文本分享存储方法

实现一个阅后即焚的短文本分享服务，使用Golang标准库构建RESTful API，通过POST /create创建带过期策略的文本，返回唯一ID，GET /view/{id}一次性或限时访问内容，利用map+sync.RWMutex实现并发安全的内存存储，配合随机ID生成与时间戳完成销毁逻辑，支持按查看次数和有效期自动清理，适合学习或轻量级部署场景。

想快速实现一个短文本分享与存储服务？用 Golang 写一个轻量级的 Web 服务非常合适。它性能高、部署简单，适合处理这类短文本存取场景。下面是一个基于标准库的完整实现思路，包含 API 设计、数据存储、过期机制和基础安全控制。

功能需求说明

核心功能包括：

• 接收文本并生成唯一 ID
• 支持一次性查看或限时查看
• 通过 URL 访问获取内容
• 内容查看后可自动删除

API 接口设计

使用简洁的 RESTful 风格路由：

• POST /create：上传短文本，返回访问 ID
• GET /view/{id}：查看内容，查看后可选择销毁

请求体示例（/create）：

{
  "text": "这是一段秘密消息",
  "expire_after_views": 1,
  "expire_after_seconds": 3600
}

内存存储结构实现

使用 Go 的 map 模拟存储，配合 sync.RWMutex 保证并发安全：

type Paste struct {
    Text               string `json:"text"`
    ExpireAfterViews   int    `json:"expire_after_views"`
    ExpireAfterSeconds int64  `json:"expire_after_seconds"`
    CreatedAt          int64  `json:"created_at"`
}

var (
    data = make(map[string]Paste)
    mu   = sync.RWMutex{}
)

func savePaste(id string, paste Paste) {
    mu.Lock()
    defer mu.Unlock()
    data[id] = paste
}

func getPaste(id string) (Paste, bool) {
    mu.RLock()
    defer mu.RUnlock()
    paste, exists := data[id]
    return paste, exists
}

func deletePaste(id string) {
    mu.Lock()
    defer mu.Unlock()
    delete(data, id)
}

核心逻辑处理

检查内容是否过期或已阅完：

func isExpired(paste Paste) bool {
    if paste.ExpireAfterSeconds > 0 {
        if time.Now().Unix()-paste.CreatedAt > paste.ExpireAfterSeconds {
            return true
        }
    }
    return false
}

处理查看请求：

func viewHandler(w http.ResponseWriter, r *http.Request) {
    id := strings.TrimPrefix(r.URL.Path, "/view/")

    paste, exists := getPaste(id)
    if !exists {
        http.Error(w, "内容不存在", http.StatusNotFound)
        return
    }

    if isExpired(paste) {
        deletePaste(id)
        http.Error(w, "内容已过期", http.StatusGone)
        return
    }

    // 减少可查看次数
    paste.ExpireAfterViews--
    if paste.ExpireAfterViews <= 0 {
        deletePaste(id)
    } else {
        savePaste(id, paste)
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"text": paste.Text})
}

创建新短文本：

func createHandler(w http.ResponseWriter, r *http.Request) {
    var req struct {
        Text               string `json:"text"`
        ExpireAfterViews   int    `json:"expire_after_views"`
        ExpireAfterSeconds int64  `json:"expire_after_seconds"`
    }

    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "请求格式错误", http.StatusBadRequest)
        return
    }

    if req.Text == "" {
        http.Error(w, "文本不能为空", http.StatusBadRequest)
        return
    }

    if req.ExpireAfterViews == 0 {
        req.ExpireAfterViews = 1
    }

    id := generateShortID()
    paste := Paste{
        Text:               req.Text,
        ExpireAfterViews:   req.ExpireAfterViews,
        ExpireAfterSeconds: req.ExpireAfterSeconds,
        CreatedAt:          time.Now().Unix(),
    }

    savePaste(id, paste)

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"id": id})
}

生成短 ID 可使用随机字符串：

func generateShortID() string {
    const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    bytes := make([]byte, 6)
    for i := range bytes {
        bytes[i] = letters[rand.Intn(len(letters))]
    }
    return string(bytes)
}

启动 HTTP 服务

注册路由并运行服务：

func main() {
    rand.Seed(time.Now().UnixNano())

    http.HandleFunc("/create", createHandler)
    http.HandleFunc("/view/", viewHandler)

    fmt.Println("服务启动在 :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

测试方式：

curl -X POST http://localhost:8080/create \
  -H "Content-Type: application/json" \
  -d '{"text":"你好世界","expire_after_seconds":60}'

返回：

{"id":"abc123"}

然后访问：http://localhost:8080/view/abc123

基本上就这些。这个实现足够用于学习或小规模使用。如需上线，可加入持久化（如 BoltDB）、限流、HTTPS 和更复杂的前端交互。不复杂但容易忽略的是过期检查和并发读写保护，Go 的原生支持让这些变得很直观。