从Java到Go：后端服务迁移的关键考量与实践建议

package main

import (
    "context"
    "database/sql"
    "fmt"
    "log"
    "os/exec"
    "sync"
    "time"

    _ "github.com/go-sql-driver/mysql" // 假设使用此驱动
)

// Command represents a shell command to be executed
type Command struct {
    ID      int
    CmdText string
}

// Result represents the execution result
type Result struct {
    CommandID int
    Output    string
    Error     string
    Success   bool
}

// fetchCommandsFromDB simulates fetching commands from a database
func fetchCommandsFromDB(db *sql.DB) ([]Command, error) {
    // In a real application, you'd query the database here
    // For demonstration, return some dummy commands
    return []Command{
        {ID: 1, CmdText: "echo Hello from Go 1"},
        {ID: 2, CmdText: "sleep 2 && echo Done sleep 2"},
        {ID: 3, CmdText: "ls -l /nonexistent || echo File not found"},
        {ID: 4, CmdText: "echo Hello from Go 4"},
    }, nil
}

// saveResultToDB simulates saving results to a database
func saveResultToDB(db *sql.DB, result Result) error {
    // In a real application, you'd insert/update the database here
    fmt.Printf("Saving result for Command ID %d: Success=%t, Output='%s', Error='%s'\n",
        result.CommandID, result.Success, result.Output, result.Error)
    return nil
}

func worker(id int, commands <-chan Command, results chan<- Result, db *sql.DB) {
    for cmd := range commands {
        log.Printf("Worker %d: Executing command ID %d: '%s'", id, cmd.ID, cmd.CmdText)
        ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) // Set a timeout for the command
        defer cancel()

        command := exec.CommandContext(ctx, "bash", "-c", cmd.CmdText) // Use bash -c to execute complex commands
        output, err := command.CombinedOutput() // Capture both stdout and stderr

        result := Result{CommandID: cmd.ID}
        if err != nil {
            result.Success = false
            result.Error = err.Error()
            if ctx.Err() == context.DeadlineExceeded {
                result.Error += " (Timeout)"
            }
        } else {
            result.Success = true
        }
        result.Output = string(output)

        // Save result to DB (or send to another goroutine for batch saving)
        if err := saveResultToDB(db, result); err != nil {
            log.Printf("Worker %d: Failed to save result for Command ID %d: %v", id, cmd.ID, err)
        }
        results <- result // Send result back to main for potential further processing
    }
}

func main() {
    // db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database")
    // if err != nil {
    //  log.Fatalf("Failed to connect to database: %v", err)
    // }
    // defer db.Close()
    // For this example, db is nil as we are simulating DB operations
    var db *sql.DB = nil 

    commands, err := fetchCommandsFromDB(db)
    if err != nil {
        log.Fatalf("Failed to fetch commands: %v", err)
    }

    numWorkers := 3 // Number of concurrent workers
    commandChan := make(chan Command, len(commands))
    resultChan := make(chan Result, len(commands))
    var wg sync.WaitGroup

    // Start workers
    for i := 1; i <= numWorkers; i++ {
        wg.Add(1)
        go func(workerID int) {
            defer wg.Done()
            worker(workerID, commandChan, resultChan, db)
        }(i)
    }

    // Send commands to the channel
    for _, cmd := range commands {
        commandChan <- cmd
    }
    close(commandChan) // Close the channel when all commands are sent

    // Wait for all workers to finish
    wg.Wait()
    close(resultChan) // Close the result channel when all workers are done

    // Process results (optional)
    fmt.Println("\nAll commands processed. Final results:")
    for res := range resultChan {
        fmt.Printf("Command %d processed. Success: %t\n", res.CommandID, res.Success)
    }
}