Golang Web开发简明教程：从零开始构建你的第一个Web应用

mkdir blogpost-demo-mbticelebrities

go mod init github.com/axiaoxin-com/blogpost-demo-mbticelebritie

touch main.go

// 这是我们 package 的名称
// 使用这个包名的所有内容都可以看到同一个包中的其他内容，
// 不管它们在哪个文件中
package main

// 这些是我们将要使用的库
// "fmt"和"net"都是Go标准库的一部分
import (
	// "fmt"有格式化I/O操作的方法(比如打印到控制台)
	"fmt"
	// "net/http"库有实现HTTP客户端和服务器的方法
	"net/http"
)

func main() {
	// 在DefaultServeMux中为给定模式注册处理函数
	// HandleFunc方法接受路径和函数作为参数，
	// 我们可以将函数作为参数传递，在 Go 中甚至可以将它们视为变量
	// 然而，handler函数必须有适当的函数签名(如下面的"handler"函数)
	http.HandleFunc("/", handler)

	// 在定义了我们的服务器后，我们最终在端口8080上“监听和服务”
	// 第二个参数是处理函数，我们将在后面讲到，但现在它被保留为nil，
	// 在这种情况下将会使用上面通过"HandleFunc"中注册到DefaultServeMux的 handler 处理函数
	http.ListenAndServe(":8080", nil)
}

// "handler"是我们的处理函数。它必须遵循ResponseWriter和Request类型的函数签名作为参数。
func handler(w http.ResponseWriter, r *http.Request) {
	// 在本示例中，我们将始终把“Hello World”输送到ResponseWriter中
	fmt.Fprintf(w, "Hello World!")
}

go run main.go

curl localhost:8080

curl localhost:8080/path-to-a
curl -XPOST localhost:8080/path-to-b
curl -XPUT localhost:8080/mbti

go get github.com/gorilla/mux

package main

import (
	"fmt"
	"net/http"
    // 导入我们刚刚安装的 gorilla/mux 库
	"github.com/gorilla/mux"
)

func main() {
    // 声明一个新的路由器
	r := mux.NewRouter()

	// 这是路由器有用的地方，它允许我们声明路径，和对其有效的请求方法
	r.HandleFunc("/hello", handler).Methods("GET")

	// 在声明所有路由后，我们可以将这个路由器传递给这个方法
    // (之前我们是将第二个参数保留为nil)
	http.ListenAndServe(":8080", r)
}

func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello World!")
}

// main_test.go

package main

import (
	"net/http"
	"net/http/httptest"
	"testing"
)

func TestHandler(t *testing.T) {
	// 这里，我们创建一个新的HTTP请求实例。这个请求将被传递给 handler。
	// 第一个参数是请求方法，第二个参数是路由(我们暂时把它留空)，第三个参数是请求体，在本例中没有。
	req, err := http.NewRequest("GET", "", nil)
	// 如果在创建请求实例时出现错误，我们会失败并停止测试
	if err != nil {
		t.Fatal(err)
	}

	// 我们使用 Go 的 httptest 库来创建一个 http 记录器。
	// 这个记录器将作为我们 http 请求的目标（你可以把它想象成一个迷你浏览器，它将接受我们发出的http请求的结果）。
	recorder := httptest.NewRecorder()

	// 使用我们的 handler 创建一个 HTTP 处理函数。 “handler”是我们要测试的 main.go 文件中定义的处理函数
	hf := http.HandlerFunc(handler)

	// 将HTTP请求发送到我们的记录器。这一行实际上执行了我们想要测试的 handler 处理函数
	hf.ServeHTTP(recorder, req)

	// 检查状态码是否符合我们的预期。
	if status := recorder.Code; status != http.StatusOK {
		t.Errorf("handler returned wrong status code: got %v want %v",
			status, http.StatusOK)
	}

	// 检查响应 body 是否符合我们的预期。
	expected := `Hello World!`
	actual := recorder.Body.String()
	if actual != expected {
		t.Errorf("handler returned unexpected body: got %v want %v", actual, expected)
	}
}

go test ./...

package main

import (
	"fmt"
	"net/http"

	"github.com/gorilla/mux"
)

// 这个函数创建并返回路由器。
// 因此我们可以使用这个函数在main函数之外实例化和测试路由器
func newRouter() *mux.Router {
	r := mux.NewRouter()
	r.HandleFunc("/hello", handler).Methods("GET")
	return r
}

func main() {
	// 现在通过调用上面定义的 newRouter 构造函数来创建路由器。
	// 其余代码保持不变
	r := newRouter()
	http.ListenAndServe(":8080", r)
}

func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello World!")
}

func TestRouter(t *testing.T) {
	// 使用前面定义的构造函数实例化路由器
	r := newRouter()

	// 使用“httptest”库的 `NewServer` 方法创建一个新服务器
	// 文档：https://golang.org/pkg/net/http/httptest/#NewServer
	mockServer := httptest.NewServer(r)

	// mockServer 运行了一个服务器，通过它的 URL 属性对外暴露了服务器地址
	// 我们向路由器中定义的“hello”路由发起一个GET请求
	resp, err := http.Get(mockServer.URL + "/hello")
	// 处理任何意外错误
	if err != nil {
		t.Fatal(err)
	}

	// 我们希望状态码是 200 (ok)
	if resp.StatusCode != http.StatusOK {
		t.Errorf("Status should be ok, got %d", resp.StatusCode)
	}

	// 在接下来的几行中，读取响应体，并将其转换为字符串
	defer resp.Body.Close()
	// 将body读入一串字节中(b)
	b, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		t.Fatal(err)
	}
	// 将 bytes 转换为 string
	respString := string(b)
	expected := "Hello World!"

	// 我们希望我们的响应与我们的处理函数中定义的响应相匹配。
	// 如果它碰巧是“Hello world!”，那么确认路由是正确的
	if respString != expected {
		t.Errorf("Response should be %s, got %s", expected, respString)
	}
}

func TestRouterForNonExistentRoute(t *testing.T) {
	r := newRouter()
	mockServer := httptest.NewServer(r)
	// 大部分代码都是相似的。唯一的区别是现在我们向一个没有定义的路由发出请求，比如 POST /hello 路由。
	resp, err := http.Post(mockServer.URL+"/hello", "", nil)
	if err != nil {
		t.Fatal(err)
	}

	// 我们希望我们的状态为 405（方法不允许）
	if resp.StatusCode != http.StatusMethodNotAllowed {
		t.Errorf("Status should be 405, got %d", resp.StatusCode)
	}

	// 测试 body 的代码也基本相同，但这次，我们期望得到的是一个空 body
	defer resp.Body.Close()
	b, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		t.Fatal(err)
	}
	respString := string(b)
	expected := ""

	if respString != expected {
		t.Errorf("Response should be %s, got %s", expected, respString)
	}
}

mkdir assets

touch assets/index.html

func newRouter() *mux.Router {
	r := mux.NewRouter()
	r.HandleFunc("/hello", handler).Methods("GET")

	// 声明静态文件目录并将其指向我们刚刚创建的目录
	staticFileDirectory := http.Dir("./assets/")
	// 声明处理函数，将请求路由到它们各自的文件名。
	// 文件服务器被包装在 `stripPrefix` 方法中，因为我们想在查找文件时去掉“/assets/”前缀。
	// 例如，如果我们在浏览器中键入“/assets/index.html”，文件服务器将仅在上面声明的目录中查找“index.html”。
	// 如果我们不去除前缀，文件服务器将查找“./assets/assets/index.html”，并产生错误
	staticFileHandler := http.StripPrefix("/assets/", http.FileServer(staticFileDirectory))
	// “PathPrefix”方法充当匹配器，匹配所有以“/assets/”开头的路由
	r.PathPrefix("/assets/").Handler(staticFileHandler).Methods("GET")
	return r
}

func TestStaticFileServer(t *testing.T) {
	r := newRouter()
	mockServer := httptest.NewServer(r)

	// 我们想要点击 `GET /assets/` 路由来获取 index.html 文件响应
	resp, err := http.Get(mockServer.URL + "/assets/")
	if err != nil {
		t.Fatal(err)
	}

	// 希望状态码是 200 (ok)
	if resp.StatusCode != http.StatusOK {
		t.Errorf("Status should be 200, got %d", resp.StatusCode)
	}

	// 测试 HTML 文件的全部内容是不明智的。
	// 我们测试 content-type 标头是“text/html; charset=utf-8”，这样我们就知道已经提供了一个 html 文件
	contentType := resp.Header.Get("Content-Type")
	expectedContentType := "text/html; charset=utf-8"

	if expectedContentType != contentType {
		t.Errorf("Wrong content type, expected %s, got %s", expectedContentType, contentType)
	}
}

go run main.go

<!DOCTYPE html>
<html lang="zh-cmn-Hans">

<head>
 <title>MBTI 名人录</title>
</head>

<body>
  <h1>MBTI 名人录</h1>
  <!--
      这个区域将用于显示名人列表及其MBTI类型
   -->
  <table>
    <tr>
      <th>人名</th>
      <th>MBTI人格</th>
    </tr>
    <td>徐志摩</td>
    <td>INFP</td>
    </tr>
  </table>
  <br/>

  <!--
      此部分包含表单，将用于点击我们将在下一节中构建的 `POST /items` API
   -->
  <form action="/items" method="post">
    人名:
    <input type="text" name="name">
    <br/> MBTI人格:
    <input type="text" name="mbti">
    <br/>
    <input type="submit" value="提交">
  </form>

  <!--
    最后，是在每次页面加载时运行的脚本，以获取名人MBTI列表并将它们添加到我们现有的 table 表中
   -->
  <script>
    celebritiesTable = document.querySelector("table")

    /*
    使用浏览器的 `fetch` API 对 /items 进行 GET 调用
    我们希望响应是 MBTI 名人录的 JSON 列表，格式如下：
    [
      {"name":"...","mbti":"..."},
      {"name":"...","mbti":"..."}
    ]
    */
    fetch("/items")
      .then(response => response.json())
      .then(items => {
        // 一旦我们获取了列表，我们就遍历它
        items.forEach(item => {
          // 创建表行
          row = document.createElement("tr")

          // 为人名和 MBTI 人格类型列创建表数据元素
          nameTd = document.createElement("td")
          nameTd.innerHTML = item.name
          mbtiTd = document.createElement("td")
          mbtiTd.innerHTML = item.mbti

          // 将数据元素添加到行中
          row.appendChild(nameTd)
          row.appendChild(mbtiTd)
          // 最后，将行元素添加到 table 中
          celebritiesTable.appendChild(row)
        })
      })
  </script>
</body>

package main

type Item struct {
	Name string `json:"name"`
	MBTI string `json:"mbti"`
}

var items []Item

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

type Item struct {
	Name string `json:"name"`
	MBTI string `json:"mbti"`
}

var items []Item

func getItemsHandler(w http.ResponseWriter, r *http.Request) {
	// 将“items”变量转换为 json
	itemsBytes, err := json.Marshal(items)
	// 如果有错误，打印到控制台，并返回一个服务器错误给用户
	if err != nil {
		fmt.Println(fmt.Errorf("Error: %v", err))
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	// 如果一切顺利，将名人 MBTI 的 JSON 列表写入响应
	w.Write(itemsBytes)
}

func createItemHandler(w http.ResponseWriter, r *http.Request) {
	// 创建 Item 实例
	item := Item{}

	// 我们使用 `ParseForm` 方法，解析请求发送过来的 HTML 表单数据
	err := r.ParseForm()
	// 如果出现任何错误，我们将返回错误给用户
	if err != nil {
		fmt.Println(fmt.Errorf("Error: %v", err))
		w.WriteHeader(http.StatusInternalServerError)
		return
	}

	// 从表单信息中获取对应字段的信息
	item.Name = r.Form.Get("name")
	item.MBTI = r.Form.Get("mbti")

	// 将新的 item 添加我们现有的 items 列表
	items = append(items, item)

	// 最后，我们使用 http 库的 `Redirect` 方法将用户重定向到原始的 HTMl 页面（位于 `/assets/`）
	http.Redirect(w, r, "/assets/", http.StatusFound)
}

// 在返回 r 之前添加这些行到 newRouter() 函数中
r.HandleFunc("/bird", getBirdHandler).Methods("GET")
r.HandleFunc("/bird", createBirdHandler).Methods("POST")
return r