Go语言中构建JSONP响应的优雅实践

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "regexp" // 用于回调函数名称的安全性校验
)

// APIResponse 模拟响应数据结构
type APIResponse struct {
    Message string `json:"message"`
    Status  string `json:"status"`
}

// jsonpHandler 处理JSONP请求
func jsonpHandler(w http.ResponseWriter, r *http.Request) {
    // 1. 获取回调函数名称
    callback := r.FormValue("callback")

    // 2. 构造响应数据
    respData := APIResponse{
        Message: "Hello from Go JSONP!",
        Status:  "success",
    }

    // 3. 将数据序列化为JSON字节切片
    jsonBytes, err := json.Marshal(respData)
    if err != nil {
        http.Error(w, "Internal server error: failed to marshal JSON", http.StatusInternalServerError)
        log.Printf("Error marshaling JSON: %v", err)
        return
    }

    // 4. 根据是否存在回调函数，设置Content-Type并写入响应
    if callback != "" {
        // 安全性校验：防止恶意回调函数名称注入
        if !isValidCallbackName(callback) {
            http.Error(w, "Invalid callback function name", http.StatusBadRequest)
            return
        }
        // 设置Content-Type为JavaScript
        w.Header().Set("Content-Type", "application/javascript")
        // 使用fmt.Fprintf直接格式化并写入响应
        fmt.Fprintf(w, "%s(%s)", callback, jsonBytes)
    } else {
        // 如果没有回调函数，则直接返回纯JSON
        w.Header().Set("Content-Type", "application/json")
        w.Write(jsonBytes)
    }
}

// isValidCallbackName 校验回调函数名称的合法性
func isValidCallbackName(name string) bool {
    // 典型的JavaScript函数名规则：以字母、下划线或$开头，后续可包含数字
    // 注意：这只是一个基本示例，更严格的校验可能需要考虑保留字等
    match, _ := regexp.MatchString("^[a-zA-Z_$][a-zA-Z0-9_$]*$", name)
    return match
}

func main() {
    http.HandleFunc("/jsonp", jsonpHandler)
    log.Println("Server listening on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatalf("Server failed to start: %v", err)
    }
}

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "regexp" // 用于回调函数名称的安全性校验
)

// APIResponse 模拟响应数据结构 (与上例相同)
type APIResponse struct {
    Message string `json:"message"`
    Status  string `json:"status"`
}

// jsonpHandlerSprintf 处理JSONP请求，使用fmt.Sprintf
func jsonpHandlerSprintf(w http.ResponseWriter, r *http.Request) {
    callback := r.FormValue("callback")

    respData := APIResponse{
        Message: "Hello from Go JSONP (Sprintf)!",
        Status:  "success",
    }

    jsonBytes, err := json.Marshal(respData)
    if err != nil {
        http.Error(w, "Internal server error: failed to marshal JSON", http.StatusInternalServerError)
        log.Printf("Error marshaling JSON: %v", err)
        return
    }

    var finalResponseBytes []byte
    if callback != "" {
        // 安全性校验
        if !isValidCallbackName(callback) {
            http.Error(w, "Invalid callback function name", http.StatusBadRequest)
            return
        }
        // 使用fmt.Sprintf构建最终的JSONP字符串，然后转换为字节切片
        finalResponseBytes = []byte(fmt.Sprintf("%s(%s)", callback, jsonBytes))
        w.Header().Set("Content-Type", "application/javascript")
    } else {
        // 没有回调函数，直接使用原始JSON字节
        finalResponseBytes = jsonBytes
        w.Header().Set("Content-Type", "application/json")
    }

    // 统一通过w.Write()写入最终的字节切片
    w.Write(finalResponseBytes)
}

// isValidCallbackName 校验回调函数名称的合法性 (与上例相同)
func isValidCallbackName(name string) bool {
    match, _ := regexp.MatchString("^[a-zA-Z_$][a-zA-Z0-9_$]*$", name)
    return match
}

func main() {
    http.HandleFunc("/jsonp", jsonpHandler) // 使用fmt.Fprintf的处理器
    http.HandleFunc("/jsonp-sprintf", jsonpHandlerSprintf) // 使用fmt.Sprintf的处理器
    log.Println("Server listening on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatalf("Server failed to start: %v", err)
    }
}