RESTfull API是現在很流行的 API 設計風格。眾所周知的 HTTP 1.1規範正是基於 REST 架構風格的指導原理來設計的。需要注意的是，REST 是一種風格而不是標準。如果一個架構符合 REST 原則，我們就稱它為 RESTful 架構。

先來實現一個最簡單的，啟動一個 RESTful 服務。程式碼示例

package main

import (
    "net/http"
    "fmt"
    "html"
    "log"
)

func main() {
    http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
        fmt.Fprintln(writer, "Hello, ", html.EscapeString(request.URL.Path))
    })
    log.Fatal(http.ListenAndServe(":8080",nil))
}
 

執行這段程式碼，然後開啟瀏覽器訪問 http://localhost:8080

然後再加上路徑看看 http://localhost:8080/joel/mak

你會發現網頁輸出瞭如下內容

Hello,  /joel/mak

是的，它輸出了當前的路徑。

路徑又稱“終點”（endpoint），用來表示 API 的具體地址。在 RESTful 架構中，每個網址代表一個資源（resource）。為了更好的使用這些網址，我們需要有統一的路徑分發功能。這裡使用第三方的包（Gorilla Mux package）："github.com/gorilla/mux"

實現根據不同的訪問路徑，給出不同的頁面內容的功能。

那麼根據路徑的不同，需要有不同的函式來各自實現。 程式碼中，我們用 Index、TodoIndex、TodoShow 三個函式來實現不同內容的頁面列印。

package main

import (
    "github.com/gorilla/mux"
    "net/http"
    "fmt"
    "log"
)

func main() {
    router := mux.NewRouter().StrictSlash(true)
    router.HandleFunc("/", Index)
    router.HandleFunc("/todos", TodoIndex)
    router.HandleFunc("/todos/{todoId}", TodoShow)

    log.Fatal(http.ListenAndServe(":8080", router))
}
func TodoShow(writer http.ResponseWriter, request *http.Request) {
    vars := mux.Vars(request)
    todoId := vars["todoId"]
    fmt.Fprintln(writer, "Todo show:", todoId)
}
func TodoIndex(writer http.ResponseWriter, request *http.Request) {
    fmt.Fprintln(writer, "Todo Index!",request.URL.Path)
}
func Index(writer http.ResponseWriter, request *http.Request) {
    fmt.Fprintln(writer, "Welcome!")
}
 

執行以上程式碼。然後，

在瀏覽器中輸入 http://localhost:8080

頁面顯示

Welcome!

在瀏覽器中輸入 http://localhost:8080/todos

頁面顯示

Todo Index! /todos

在瀏覽器中輸入 http://localhost:8080/todos/{123}

頁面顯示

Todo show: {123}

按照一般的軟體過程，我們再把上面的程式碼進行抽象。 分別把資料模型和功能抽象成 Todo.go、Routes.go、Handlers.go

以下為程式碼示例

main.go

package main

import (
    "net/http"
    "log"
)

func main() {
    router := NewRouter()
    log.Fatal(http.ListenAndServe(":8080", router))
}

是不是主函式 main 清爽了呢？因為其他的部分都被抽象出去了。

Todo.go

package main

import "time"

type Todo struct {
    Id      int     `json:"id"`
    Name    string  `json:"name"`
    Completed   bool    `json:"completed"`
    Due     time.Time   `json:"due"`
}

type Todos  []Todo

go 語言沒有 class，必須使用結構來構造資料模型 Todo

Routes.go

package main

import "net/http"

type Route struct {
    Name        string
    Method      string
    Pattern     string
    HandlerFunc http.HandlerFunc
}

type Routes []Route

var routes = Routes{
    Route{Name:"Index",     Method:"GET",   Pattern:"/",                HandlerFunc:Index},
    Route{Name:"TodoIndex", Method:"GET",   Pattern:"/todos",           HandlerFunc:TodoIndex},
    Route{Name:"TodoShow",  Method:"GET",   Pattern:"/todos/{todoId}",  HandlerFunc:TodoShow},
}

go 語言沒有 class，必須使用結構來構造資料模型 Route 。

建立了一個變數 routes ，按照 Route 結構存放了多個 Route。而每個 Route 對應了不同的路徑。其中不同的 HandlerFunc在 Handlers.go 中實現。

Handlers.go

package main

import (
    "net/http"
    "fmt"
    "encoding/json"
    "github.com/gorilla/mux"
    "time"
)

func Index(w http.ResponseWriter, r *http.Request)  {
    fmt.Fprintln(w, "Welcome!")
}

func TodoIndex(w http.ResponseWriter, r *http.Request)  {
    todos := Todos{
        Todo{Name:"Write presentation"},
        Todo{Name:"Host meetup"},
        Todo{Id:22,Name:"Joel",Completed:true,Due:time.Now()},
    }
    if err := json.NewEncoder(w).Encode(todos); err != nil{
        panic(err)
    }
}

func TodoShow(w http.ResponseWriter, r *http.Request)  {
    vars := mux.Vars(r)
    todoId := vars["todoId"]
    fmt.Fprintln(w, "Todo show:", todoId)
}

分別實現了 Index、TodoIndex、TodoShow，以便 Route 呼叫。

Router.go

package main

import (
    "github.com/gorilla/mux"
    "net/http"
)

func NewRouter() *mux.Router {
    router := mux.NewRouter().StrictSlash(true)
    for _, route := range routes {
        var handler http.Handler
        handler = route.HandlerFunc 
        handler = logger(handler, route.Name)

        router.
        Methods(route.Method).
        Path(route.Pattern).
        Name(route.Name).
        Handler(handler)
    }
    return router
}

Router 裡的 handler = logger(handler, route.Name) 是做什麼用的？這是日誌。 多數現代的 web 服務都會有一個日誌。go 語言的標準庫裡沒有 web loging 包。所以我們自己建一個。

這樣當程式執行的時候，就會有執行日誌記錄下來。

Logger.go

package main

import (
    "net/http"
    "time"
    "log"
)

func logger(inner http.Handler, name string) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        inner.ServeHTTP(w, r)
        log.Printf("CofoxAPI: %st%st%st%s", r.Method, r.RequestURI, name, time.Since(start))
    })
}

記錄每次訪問的時間、方法、路徑及耗時。

因為沒有做什麼業務，所以執行是相當的快。

執行效果