Golang RESTful API的简单实现

RESTfull API是现在很流行的API设计风格。众所周知HTTP1.1规范正是基于REST架构风格的指导原理来设计的。需要注意的是，REST是一种风格而不是标准。如果一个架构复合REST原则，我们就称它为RESTful架构。

先来实现一个最简单的，启动一个RESTFul服务。代码示例：

1. package main

2. import (

3. "net/http"

4. "fmt"

5. "html"

6. "log"

7. )

8. func main() {

9. http.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {

10. fmt.Fprintln(writer, "Hello, ", html.EscapeString(request.URL.Path))

11. })

12. log.Fatal(http.ListenAndServe(":8080",nil))

13. }

运行这段代码，然后打开浏览器访问http://localhost:8080。

然后再加上路径看看http://localhost:8080/joel/mak。你会发现网页输出了如下内容：

hello,  /joel/mak

是的，它输出了当前的路径。路径又称"终点"(endpoint),用来表示API的具体地址。在RESTFul架构中，每个网址代表一个个资源(resource)。为了更好的使用这些网址，我们需要有统一的路径分发功能。这里使用第三方的包(Gorila Muxpackage):"github.com/gorilla/mux"。

那么根据路径的不同，需要有不同的函数来各自实现。代码中，我们用Index、TodoIndex、TodoShow三个函数来实现不同内容的页面打印。

1. package main

2. import (

3. "github.com/gorilla/mux"

4. "net/http"

5. "fmt"

6. "log"

7. )

8. func main() {

9. router := mux.NewRouter().StrictSlash(true)

10. router.HandleFunc("/", Index)

11. router.HandleFunc("/todos", TodoIndex)

12. router.HandleFunc("/todos/{todoId}", TodoShow)

13. log.Fatal(http.ListenAndServe(":8080", router))

14. }

15. func TodoShow(writer http.ResponseWriter, request *http.Request) {

16. vars := mux.Vars(request)

17. todoId := vars["todoId"]

18. fmt.Fprintln(writer, "Todo show:", todoId)

19. }

20. func TodoIndex(writer http.ResponseWriter, request *http.Request) {

21. fmt.Fprintln(writer, "Todo Index!",request.URL.Path)

22. }

23. func Index(writer http.ResponseWriter, request *http.Request) {

24. fmt.Fprintln(writer, "Welcome!")

25. }

运行以上代码。然后，在浏览器中输入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

1. package main

2. import (

3. "net/http"

4. "log"

5. )

6. func main() {

7. router := NewRouter()

8. log.Fatal(http.ListenAndServe(":8080", router))

9. }

Todo.go

1. package main

2. import "time"

3. type Todo struct {

4. Id int `json:"id"`

5. Name string `json:"name"`

6. Completed bool `json:"completed"`

7. Due time.Time `json:"due"`

8. }

9. type Todos []Todo

go语言没有class，必须使用结构体来构造数据模型Todo。

Routes.go

1. package main

2. import "net/http"

3. type Route struct {

4. Name string

5. Method string

6. Pattern string

7. HandlerFunc http.HandlerFunc

8. }

9. type Routes []Route

10. var routes = Routes{

11. Route{Name:"Index", Method:"GET", Pattern:"/", HandlerFunc:Index},

12. Route{Name:"TodoIndex", Method:"GET", Pattern:"/todos", HandlerFunc:TodoIndex},

13. Route{Name:"TodoShow", Method:"GET", Pattern:"/todos/{todoId}", HandlerFunc:TodoShow},

14. }

go语言没有class，必须使用结构体来构造数据模型Route。

建立一个变量routes，按照Route结构存放了多个Route。而每个Route对应了不同的路径。其中不同的HandlerFunc在Handlers.go中实现。

Handlers.go

1. package main

2. import (

3. "net/http"

4. "fmt"

5. "encoding/json"

6. "github.com/gorilla/mux"

7. "time"

8. )

9. func Index(w http.ResponseWriter, r *http.Request) {

10. fmt.Fprintln(w, "Welcome!")

11. }

12. func TodoIndex(w http.ResponseWriter, r *http.Request) {

13. todos := Todos{

14. Todo{Name:"Write presentation"},

15. Todo{Name:"Host meetup"},

16. Todo{Id:22,Name:"Joel",Completed:true,Due:time.Now()},

17. }

18. if err := json.NewEncoder(w).Encode(todos); err != nil{

19. panic(err)

20. }

21. }

22. func TodoShow(w http.ResponseWriter, r *http.Request) {

23. vars := mux.Vars(r)

24. todoId := vars["todoId"]

25. fmt.Fprintln(w, "Todo show:", todoId)

26. }

分别实现了Index、TodoIndex、TodoShow，以便Route调用。

Router.go

1. package main

2. import (

3. "github.com/gorilla/mux"

4. "net/http"

5. )

6. func NewRouter() *mux.Router {

7. router := mux.NewRouter().StrictSlash(true)

8. for _, route := range routes {

9. var handler http.Handler

10. handler = route.HandlerFunc

11. handler = logger(handler, route.Name)

12. router.

13. Methods(route.Method).

14. Path(route.Pattern).

15. Name(route.Name).

16. Handler(handler)

17. }

18. return router

19. }

Router里的handler=logger(handler，route.Name)是做什么的？这是日志。多数现代的web服务都会一个日志。go语言的标准库里没有web loging包。我们需要自己创建一个。

当程序运行的时候，就会有运行日志记录下来。

Logger.go

1. package main

2. import (

3. "net/http"

4. "time"

5. "log"

6. )

7. func logger(inner http.Handler, name string) http.Handler {

8. return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

9. start := time.Now()

10. inner.ServeHTTP(w, r)

11. log.Printf("CofoxAPI: %s\t%s\t%s\t%s", r.Method, r.RequestURI, name, time.Since(start))

12. })

13. }

记录每次访问的时间、方法、路径及耗时。