在Golang中使用React进行服务器端渲染

Question

假设我们想要使用一个Node.js进程池，以使用React呈现一些超文本标记语言。(我并不是说这是一个好主意，只是假设情况就是这样，lulz)。

有没有办法将对请求/响应流的引用从Golang传递到Node.js进程？我认为Node.js的集群模块使用了这种技术，通过传递一个文件描述符或类似的东西。请注意，Node.js进程池(可能有3个左右的进程)将是Golang进程的子进程。

Answer 1

下面是一个非常粗略的草案，它使用一个通道来实现一个进程池，并展示了如何使用Go的io.Reader和io.Writer接口将进程和HTTP流插入在一起。代码也是on the playground的，便于复制粘贴。

请注意，我写这篇文章很匆忙，只是为了展示一下大意。不要在生产环境中使用它。我确信有bug，特别是与未完成的读或写相关的bug。在空闲时退出的进程也不会被处理。

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([]字节)向节点发送数据，并调用nodeWrapper.Read()从其标准输出中读取数据。这就是我在评论中说的意思，你通常会传递给读者和作者。

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设置为所需的编写器，然后简单地运行该进程直到完成。但是在这种情况下，进程一旦完成渲染就不会退出，所以它也不会关闭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")
})