22、Go Web开发实用指南-优快云博客

本文链接：https://blog.youkuaiyun.com/data3/article/details/151205639

Go Web开发实用指南

1. 文件上传

在Web应用中，文件上传是常见需求。要实现文件上传，首先要从HTML表单获取文件，可使用 FormFile 方法。该方法以文件输入元素的名称为参数，返回两个值和一个错误。第一个值是文件（ io.ReadCloser 类型），第二个值是文件元数据（ multipart.FileHeader 类型）。

以下是示例代码：

defer file.Close()
fmt.Fprintf(w, "%v", fileHeader.Header)
f, err := os.OpenFile("./uploaded/"+fileHeader.Filename,
    os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
    fmt.Println(err)
    return
}
defer f.Close()
io.Copy(f, file)

操作步骤如下：
1. 使用 FormFile 方法从HTML表单获取文件和文件元数据。
2. 利用文件元数据获取文件名，创建新文件。
3. 使用 io.Copy 函数将文件从 io.ReadCloser 复制到新文件。

可以使用 curl 命令测试文件上传，语法如下：

$ curl -F "uploadfile=@lenna.png" http://localhost:8000/upload

运行此命令后，会在 .uploaded 目录下创建 lenna.png 文件。

2. 静态文件服务

Web应用常需提供静态文件，如图片、CSS和JavaScript文件。可使用 http.FileServer 函数实现。

简单示例代码：

func main() {
    http.Handle("/", http.FileServer(http.Dir("./static")))
    http.ListenAndServe(":8000", nil)
}

操作步骤：
1. 使用 http.Dir 指定要提供服务的文件目录。
2. 调用 http.FileServer 函数，传入 http.Dir 作为参数，返回一个 http.Handler 。
3. 使用 http.Handle 函数将 http.Handler 注册为 / URL模式的处理程序。

若使用不同的URL前缀，需使用 http.StripPrefix 去除前缀，示例代码：

func main() {
    http.Handle("/static/", http.StripPrefix("/static",
        http.FileServer(http.Dir("./static"))))
    http.ListenAndServe(":8000", nil)
}

http.FileServer 会列出所服务目录的所有内容。若不想让用户看到目录内容，可在目录中创建 index.html 文件，该文件将替代目录列表显示。

若要提供单个文件，可使用 http.ServeFile ：

func main() {
    file := func(w http.ResponseWriter, r *http.Request) {
        http.ServeFile(w, r, "./static/rfc2616.txt")
    }
    http.HandleFunc("/static/http_rfc", file)
    http.ListenAndServe(":8000", nil)
}

3. 创建JSON Web服务API

若要创建返回JSON的简单Web服务API，可使用 net/http 包创建API，使用 encoding/json 包将数据编码为JSON格式返回。

创建一个返回人员列表的JSON API示例：
首先定义 Person 结构体：

type Person struct {
    Name      string `json:"name"`
    Height    string `json:"height"`
    Mass      string `json:"mass"`
    HairColor string `json:"hair_color"`
    SkinColor string `json:"skin_color"`
    EyeColor  string `json:"eye_color"`
    BirthYear string `json:"birth_year"`
    Gender    string `json:"gender"`
}
var list []Person
func init() {
    file, _ := os.Open("people.json")
    defer file.Close()
    data, _ := io.ReadAll(file)
    json.Unmarshal(data, &list)
}

创建路由和处理函数：

func main() {
    mux := chi.NewRouter()
    mux.Get("/people/{id}", people)
    http.ListenAndServe(":8000", mux)
}
func people(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    idstr := chi.URLParam(r, "id")
    id, err := strconv.Atoi(idstr)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    if id < 0 || id >= len(list) {
        w.WriteHeader(http.StatusNotFound)
        return
    }
    json.NewEncoder(w).Encode(list[id])
}

操作步骤：
1. 定义 Person 结构体。
2. 在 init 函数中从 people.json 文件读取数据并初始化 list 变量。
3. 创建路由，使用 chi.NewRouter 创建路由器，定义 /people/{id} 路径的处理函数。
4. 在处理函数中，设置响应头的 Content-Type 为 application/json ，从URL路径获取 id ，进行错误检查，若 id 无效返回相应错误，若有效则将对应人员信息编码为JSON格式返回。

4. 通过HTTPS提供服务

多数Web应用需通过HTTPS提供服务，以加密客户端与服务器间的通信。可使用 http.ListenAndServeTLS 函数实现。

示例代码：

package main
import (
    "net/http"
)
func main() {
    http.HandleFunc("/", index)
    http.ListenAndServeTLS(":8000", "cert.pem", "key.pem", nil)
}
func index(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello World"))
}

操作步骤：
1. 编写普通的HTTP处理函数。
2. 使用 http.ListenAndServeTLS 函数启动服务器，需提供证书文件 cert.pem 和私钥文件 key.pem 。

在生产环境中，可从证书颁发机构（CA）获取SSL证书，也可使用Let’s Encrypt获取免费证书。若仅用于测试，可使用 OpenSSL 生成自签名证书，命令如下：

$ openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

运行命令后，按提示输入信息，完成后将 cert.pem 和 key.pem 文件复制到 main.go 文件所在目录，再次运行代码启动服务器。在浏览器中访问 https://localhost:8000 ，可能会收到安全警告，忽略警告即可看到 Hello World 消息。

在生产环境中，可使用反向代理（如Nginx或Apache）处理TLS终止，以提高Web应用性能。

5. Go Web应用使用模板

若要创建更复杂的Web应用，可使用Go的模板系统，使用 html/template 包。

简单示例代码：

package main
import (
    "html/template"
    "net/http"
)
func hello(w http.ResponseWriter, r *http.Request) {
    t, _ := template.ParseFiles("hello.html")
    t.Execute(w, "Hello World!")
}
func main() {
    http.HandleFunc("/", hello)
    http.ListenAndServe(":8000", nil)
}

在 hello.html 模板文件中，使用 {{.}} 语法渲染数据：

<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Go Cookbook</title>
  </head>
  <body>
    <h1>{{ . }}</h1>
  </body>
</html>

模板引擎的常用操作：
- {{.}} ：渲染传递给模板的数据。
- {{range}} ：用于迭代切片或映射。
- {{if}} 、 {{else}} ：用于条件检查。

示例代码展示如何使用结构体和切片数据：

type Person struct {
    Name      string
    Gender    string
    Homeworld string
}
func person(w http.ResponseWriter, r *http.Request) {
    t, _ := template.ParseFiles("person.html")
    t.Execute(w, Person{
        Name:      "Luke Skywalker",
        Gender:    "male",
        Homeworld: "Tatooine",
    })
}
func people(w http.ResponseWriter, r *http.Request) {
    t, _ := template.ParseFiles("people.html")
    t.Execute(w, []string{"Luke", "Leia", "Han", "Chewbacca"})
}

person.html 模板文件：

<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Go Cookbook</title>
  </head>
  <body>
    <h1>{{ .Name }}</h1>
    <ul>
      <li><b>Gender:</b> {{ .Gender }}</li>
      <li><b>Home world:</b> {{ .Homeworld }}</li>
    </ul>
  </body>
</html>

people.html 模板文件：

<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Go Cookbook</title>
  </head>
  <body>
    <div>This is a list of people in Star Wars:</div>
    <ul>
        {{ range . }}
        <li>{{ . }}</li>
        {{ end }}
    </ul>
  </body>
</html>

若要进行条件检查，可在模板中使用 {{if}} 、 {{else}} ：

<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Go Cookbook</title>
  </head>
  <body>
    {{ if gt (len .) 0 }}
    <div>This is a list of people in Star Wars:</div>
    <ul>
        {{ range . }}
        <li>{{ . }}</li>
        {{ end }}
    </ul>
    {{ else }}
    <div>There are no people in this list.</div>
    {{ end }}
  </body>
</html>

总结

本文介绍了Go Web开发中的多个重要方面，包括文件上传、静态文件服务、JSON Web服务API创建、HTTPS服务和模板使用。通过详细的代码示例和操作步骤，帮助读者掌握这些技术的实现方法。在实际开发中，可根据具体需求选择合适的技术，构建功能强大、安全可靠的Web应用。

流程图

graph TD;
    A[开始] --> B[文件上传];
    B --> C[静态文件服务];
    C --> D[JSON Web服务API创建];
    D --> E[通过HTTPS提供服务];
    E --> F[Go Web应用使用模板];
    F --> G[结束];

表格

技术点	实现函数	关键操作
文件上传	`FormFile` 、 `io.Copy`	从表单获取文件，复制文件到新文件
静态文件服务	`http.FileServer` 、 `http.StripPrefix`	指定目录，处理URL前缀
JSON Web服务API创建	`net/http` 、 `encoding/json`	定义结构体，处理URL参数，编码JSON数据
通过HTTPS提供服务	`http.ListenAndServeTLS`	提供证书和私钥
Go Web应用使用模板	`html/template`	解析模板文件，执行模板渲染

Go Web开发实用指南

6. 技术点对比与选择

为了更清晰地了解不同技术点在Go Web开发中的特点和适用场景，我们可以通过一个表格进行对比：
| 技术点 | 优点 | 缺点 | 适用场景 |
| ---- | ---- | ---- | ---- |
| 文件上传 | 实现简单，能满足基本文件上传需求 | 缺乏复杂的文件处理和验证机制 | 小型网站的用户文件上传功能 |
| 静态文件服务 | 方便快捷，可直接提供静态资源 | 目录内容可能被暴露 | 网站的静态资源（如图片、CSS、JS）服务 |
| JSON Web服务API创建 | 数据传输格式统一，易于与其他系统集成 | 对数据格式要求严格 | 前后端分离的Web应用，提供数据接口 |
| 通过HTTPS提供服务 | 保障通信安全，符合安全规范 | 需要证书和私钥，配置相对复杂 | 涉及用户敏感信息的Web应用 |
| Go Web应用使用模板 | 提高代码复用性，便于页面维护 | 模板语法学习成本较高 | 构建复杂的Web页面 |

7. 综合应用示例

下面我们通过一个综合示例，将上述技术点结合起来，构建一个简单的Web应用。该应用允许用户上传文件，提供静态文件服务，有一个JSON API接口，通过HTTPS提供服务，并使用模板渲染页面。

package main

import (
    "encoding/json"
    "fmt"
    "html/template"
    "io"
    "net/http"
    "os"
    "strconv"

    "github.com/go-chi/chi"
)

type Person struct {
    Name      string `json:"name"`
    Height    string `json:"height"`
    Mass      string `json:"mass"`
    HairColor string `json:"hair_color"`
    SkinColor string `json:"skin_color"`
    EyeColor  string `json:"eye_color"`
    BirthYear string `json:"birth_year"`
    Gender    string `json:"gender"`
}

var list []Person

func init() {
    file, err := os.Open("people.json")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()
    data, err := io.ReadAll(file)
    if err != nil {
        fmt.Println(err)
        return
    }
    json.Unmarshal(data, &list)
}

func uploadFile(w http.ResponseWriter, r *http.Request) {
    file, fileHeader, err := r.FormFile("uploadfile")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer file.Close()

    f, err := os.OpenFile("./uploaded/"+fileHeader.Filename, os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer f.Close()

    io.Copy(f, file)
    fmt.Fprintf(w, "File uploaded successfully: %s", fileHeader.Filename)
}

func staticHandler(w http.ResponseWriter, r *http.Request) {
    http.ServeFile(w, r, "./static/"+r.URL.Path[len("/static/"):])
}

func people(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    idstr := chi.URLParam(r, "id")
    id, err := strconv.Atoi(idstr)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    if id < 0 || id >= len(list) {
        w.WriteHeader(http.StatusNotFound)
        return
    }
    json.NewEncoder(w).Encode(list[id])
}

func index(w http.ResponseWriter, r *http.Request) {
    t, err := template.ParseFiles("index.html")
    if err != nil {
        fmt.Println(err)
        return
    }
    t.Execute(w, "Welcome to the Go Web App!")
}

func main() {
    mux := chi.NewRouter()

    // 文件上传
    mux.Post("/upload", uploadFile)

    // 静态文件服务
    mux.Get("/static/*", staticHandler)

    // JSON Web服务API
    mux.Get("/people/{id}", people)

    // 模板页面
    mux.Get("/", index)

    // 通过HTTPS提供服务
    err := http.ListenAndServeTLS(":8000", "cert.pem", "key.pem", mux)
    if err != nil {
        fmt.Println(err)
    }
}

index.html 模板文件：

<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Go Web App</title>
  </head>
  <body>
    <h1>{{ . }}</h1>
    <form action="/upload" method="post" enctype="multipart/form-data">
      <input type="file" name="uploadfile">
      <input type="submit" value="Upload">
    </form>
    <a href="/static/rfc2616.txt">View Static File</a>
    <a href="/people/0">Get JSON Data</a>
  </body>
</html>

8. 操作步骤

准备工作 ：
- 创建 uploaded 目录用于存储上传的文件。
- 创建 static 目录，将静态文件（如 rfc2616.txt ）放入其中。
- 准备 people.json 文件，内容如下：

[
    {
        "name": "Luke Skywalker",
        "height": "172",
        "mass": "77",
        "hair_color": "blond",
        "skin_color": "fair",
        "eye_color": "blue",
        "birth_year": "19BBY",
        "gender": "male"
    },
    {
        "name": "C-3PO",
        "height": "167",
        "mass": "75",
        "hair_color": "n/a",
        "skin_color": "gold",
        "eye_color": "yellow",
        "birth_year": "112BBY",
        "gender": "n/a"
    },
    {
        "name": "R2-D2",
        "height": "96",
        "mass": "32",
        "hair_color": "n/a",
        "skin_color": "white, blue",
        "eye_color": "red",
        "birth_year": "33BBY",
        "gender": "n/a"
    }
]

- 使用`OpenSSL`生成自签名证书和私钥：

$ openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

运行程序 ：
- 将上述代码保存为 main.go ，在终端运行：

$ go run main.go

访问应用 ：
- 打开浏览器，访问 https://localhost:8000 ，可以看到欢迎页面。
- 选择文件并点击上传按钮，文件将被上传到 uploaded 目录。
- 点击“View Static File”链接，可查看静态文件。
- 点击“Get JSON Data”链接，可获取JSON数据。

9. 总结与展望

通过上述内容，我们详细介绍了Go Web开发中的多个重要技术点，并通过综合示例展示了如何将它们结合起来构建一个完整的Web应用。在实际开发中，我们可以根据具体需求灵活运用这些技术，不断优化和扩展应用功能。

未来，随着Web技术的不断发展，Go Web开发也会有更多的创新和应用。例如，结合微服务架构，使用Go的并发特性构建高性能、可扩展的分布式Web应用；利用Go的强大生态系统，集成更多的中间件和工具，提高开发效率和应用质量。

流程图

graph TD;
    A[启动Web应用] --> B[用户访问页面];
    B --> C{用户操作}
    C -->|上传文件| D[文件上传处理];
    C -->|访问静态文件| E[静态文件服务];
    C -->|请求JSON数据| F[JSON API处理];
    D --> G[文件保存到uploaded目录];
    E --> H[返回静态文件];
    F --> I[返回JSON数据];
    G --> J[页面提示上传成功];
    H --> B;
    I --> B;
    B --> K[页面渲染];
    K --> L[用户查看结果];

表格

功能模块	代码实现	关键文件
文件上传	`uploadFile` 函数	`main.go` 、 `index.html`
静态文件服务	`staticHandler` 函数	`main.go` 、 `static/*`
JSON Web服务API	`people` 函数	`main.go` 、 `people.json`
模板渲染	`index` 函数	`main.go` 、 `index.html`