Golang可执行程序动态更新JSON响应问题求助

Hey there! Let's tackle your two questions one by one, and fix that frustrating "need to restart" issue you're facing.

1. 替代实现方案：动态内存配置（推荐） #

Your current approach modifies the source code directly, but once your Go program is compiled and running, the hardcoded GetHands values live in memory—changing the source file won't update what's already loaded. The right fix is to store your config in a runtime-accessible variable (with thread safety for concurrent requests) instead of hardcoding it.

Here's a clean, working implementation:

Step 1: Define global state with thread safety #

First, set up a global struct to hold your current version info, plus a mutex to handle concurrent updates safely (since HTTP requests are processed in parallel):

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "os/exec"
    "sync"
    "strings"
)

type GetHand struct {
    Name    string `json:"name"`
    Version string `json:"version"`
}

// Global state with read-write mutex for thread safety
var (
    currentHand GetHand
    handMutex   sync.RWMutex
)

Step 2: Update the handler to modify runtime state #

Instead of editing source code, update the global currentHand variable when a valid key is received. We'll also add logic to fetch the actual version via go version or java -version:

func handler(w http.ResponseWriter, r *http.Request) {
    keys, ok := r.URL.Query()["key"]
    if !ok || len(keys) < 1 {
        log.Println("Url Param 'key' is missing")
        w.WriteHeader(http.StatusBadRequest)
        w.Write([]byte("Missing 'key' parameter (use 'go' or 'java')"))
        return
    }
    key := keys[0]
    log.Println("Url Param 'key' is:", key)

    // Lock for writing when updating the state
    handMutex.Lock()
    defer handMutex.Unlock()

    switch key {
    case "java":
        // Fetch Java version (clean up the output since java -version writes to stderr)
        cmd := exec.Command("java", "-version")
        stderr, err := cmd.StderrBytes()
        if err != nil {
            log.Println("Failed to get Java version:", err)
            currentHand = GetHand{Name: "Java", Version: "unknown"}
            break
        }
        versionLine := strings.Split(string(stderr), "\n")[0]
        currentHand = GetHand{Name: "Java", Version: strings.TrimSpace(strings.Split(versionLine, "\"")[1])}

    case "go":
        // Fetch Go version
        cmd := exec.Command("go", "version")
        output, err := cmd.Output()
        if err != nil {
            log.Println("Failed to get Go version:", err)
            currentHand = GetHand{Name: "Go", Version: "unknown"}
            break
        }
        versionParts := strings.Split(string(output), " ")
        currentHand = GetHand{Name: "Go", Version: versionParts[2]}

    default:
        log.Println("Invalid key:", key)
        w.WriteHeader(http.StatusBadRequest)
        w.Write([]byte("Invalid 'key' parameter (use 'go' or 'java')"))
        return
    }

    // Lock for reading when responding (we can use RLock() here for better read performance)
    handMutex.RLock()
    defer handMutex.RUnlock()

    if err := json.NewEncoder(w).Encode(currentHand); err != nil {
        log.Println("Failed to encode response:", err)
        w.WriteHeader(http.StatusInternalServerError)
    }
}

func main() {
    // Initialize with default value
    currentHand = GetHand{Name: "Java", Version: "1.7.0_71"}
    http.HandleFunc("/", handler)
    log.Println("Server starting on :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Why this works: #

• The currentHand variable lives in the program's memory while it's running—updates take effect immediately.
• The sync.RWMutex ensures that concurrent requests don't cause race conditions (critical for production use).
• No more modifying source code or restarting the server—changes are reflected the next time you hit the endpoint.

Alternative: Persistent config file

If you need the version info to survive server restarts, you can store it in a JSON file instead of a global variable. Just read the file when responding, and write to it when updating. Note that you'll still need a mutex to handle concurrent file access.

2. Can you run go build or go update inside the function? #

Technically, yes—you could use exec.Command to run go build from within your handler. But this is an extremely bad idea for several reasons:

• Security risk: Your current sed commands are vulnerable to command injection (if an attacker passes a malicious key value, they could execute arbitrary code on your server).
• Service disruption: Compiling and restarting the program would cause downtime, and you'd have to handle process replacement (which is complex and error-prone).
• Performance overhead: go build is resource-intensive, and running it on every request would cripple your server.
• Maintainability: Self-modifying code is a nightmare to debug and maintain—you'll spend hours tracking down issues with source code changes happening at runtime.

Save yourself the headache and stick with the runtime state approach above.

内容的提问来源于stack exchange，提问作者sneha surendranathan nair