使用React在Golang中進行服務器端渲染

Question

假設我們要使用Node.js進程池，以使用React渲染一些HTML。 （我並不是說這是一個好主意，只是假設情況確實如此，lulz）。

有沒有一種方法可以將對請求/響應流的引用從Golang傳遞到Node.js進程？ 我認為Node.js的集群模塊通過傳遞文件描述符或類似的東西來使用這種技術。 請注意，Node.js進程池（大約3個進程）將是Golang進程的子進程。

Answer 1

以下是一個非常粗略的草稿，它使用通道來實現進程池，並顯示了如何使用Go的io.Reader和io.Writer接口將進程流和HTTP流插入在一起。 該代碼也位於操場上 ，以便於復制粘貼。

請注意，我急着寫了這個，只是為了展示總體思路。 不要在生產中使用它。 我確定存在錯誤，尤其是與不完整的讀取或寫入有關的錯誤。 空閑時退出的進程也不會被處理。

package main

import (
        "encoding/json"
        "fmt"
        "io"
        "log"
        "net/http"
        "os"
        "os/exec"
)

exec.Cmd.Stdin和exec.Cmd.Stdout的類型分別為io.Reader和io.Writer。 但是，對於我們來說，反過來對待它們更方便。 StdinPipe和StdoutPipe方法可以簡化此操作，但是必須僅在過程開始之前調用它們一次。 因此，我們將管道與命令本身一起存儲在一個簡單的包裝器中。 這使我們可以調用nodeWrapper.Write（[] byte）將數據發送到node，並調用nodeWrapper.Read（）從其stdout中讀取。 這就是我在評論中說的意思，通常，您會繞過讀者和作家。

type nodeWrapper struct {
        *exec.Cmd
        io.Writer // stdin
        io.Reader // stdout
}

// mustSpawnNode returns a started nodejs process that executes render.js
func mustSpawnNode() nodeWrapper {
        cmd := exec.Command("node", "render.js")
        cmd.Stderr = os.Stderr

        stdin, err := cmd.StdinPipe()
        if err != nil {
                panic(err)
        }

        stdout, err := cmd.StdoutPipe()
        if err != nil {
                panic(err)
        }

        if err := cmd.Start(); err != nil {
                panic(err)
        }

        return nodeWrapper{cmd, stdin, stdout}
}

我們在這里使用基於通道的簡單環形緩沖區來實現進程池。

處理程序解析HTTP請求並提取呈現頁面所需的信息。 在此示例中，我們僅將請求路徑傳遞給節點。 然后，我們等待一個自由節點進程並調用render。 render將直接寫入ResponseWriter。

func main() {
        pool := make(chan nodeWrapper, 4) // acts as a ring buffer
        for i := 0; i < cap(pool); i++ {
                pool <- mustSpawnNode()
        }

        log.Println("listening on :3000")
        log.Fatal(http.ListenAndServe(":3000", handler(pool)))
}

func handler(pool chan nodeWrapper) http.HandlerFunc {
        return func(w http.ResponseWriter, r *http.Request) {
                var renderArgs struct {
                        Path string
                }
                renderArgs.Path = r.URL.Path

                node := <-pool

                err := render(w, node, renderArgs)
                if err != nil {
                        // Assume the node process has failed and replace it
                        // with a new one.
                        node.Process.Kill()
                        pool <- mustSpawnNode()
                        http.Error(w, err.Error(), 500)
                } else {
                        pool <- node
                }
        }
}

對於渲染，我們a）希望將一些數據傳遞到已經運行的節點進程，b）從節點的標准輸出讀取，更重要的是，必須知道何時停止讀取。

通常，我們會將Stdout設置為所需的編寫器，然后簡單地運行該過程即可完成。 但是在這種情況下，該過程一旦完成渲染就不會退出，因此也不會關閉stdout，因此我們需要替換通常的EOF信號。

這是我們必須發揮創造力並找到適合您的解決方案的地方。 我決定采用以下協議：我們將單行JSON編碼的數據寫入節點的stdin，然后從節點的stdout解碼單個JSON編碼的字符串。 理想情況下，我們不會將整個HTML文檔緩存在內存中，而是將其直接放在網上（通過實時寫入w）。 但這使Go代碼和render.js都變得非常簡單。

func render(w io.Writer, node nodeWrapper, args interface{}) error {
        stdinErr := make(chan error, 1)
        go func() {
                stdinErr <- json.NewEncoder(node).Encode(args)
        }()

        var html string
        if err := json.NewDecoder(node).Decode(&html); err != nil {
                return err
        }
        if _, err := fmt.Fprint(w, html); err != nil {
                return err
        }

        return <-stdinErr
}

最后，render.js的內容：

let lineReader = require('readline').createInterface({input: process.stdin})

lineReader.on('line', (line) => {
    let data = JSON.parse(line);

    let html = "";
    html += "<h1>Path: " + data.Path + "</h1>\n";
    html += "<small>PID: " + process.pid + "</small>\n";

    process.stdout.write(JSON.stringify(html)+"\n")
})