RESTful架构搜集

今天才知道RESTful这个词，感觉好落后呀。自从5月份后很少学习新知识，这是个不好的信号。

RESTful是Representational State Transfer的缩写。怎么理解Representational State Transfer呢？

• 资源（Resources):

　　所谓资源，就是一个网络实体，或者说就是网络上的一个具体信息。它可以是一段音乐，一个图片，一首歌曲，一种服务，总之就是一个具体的存在。你可以使用URI（统一资源定位符）指向他们，每种资源都有一个特定的URI。要获取这个资源，只需访问这个URI就可以了。因此这个URI就成为一个独一无二的识别符。

• 表现层（Representation）：

　　资源是一个信息实体，它可以有多种表现实体。我们把资源的具体呈现形式，称为表现层（Representation），例如：图片，txt, json等

URI只代表资源的实体，不代表它的形式。严格地说，有些网址最后的".html"后缀名是不必要的，因为这个后缀名表示格式，属于"表现层"范畴，而URI应该只代表"资源"的位置。它的具体表现形式，应该在HTTP请求的头信息中用Accept和Content-Type字段指定，这两个字段才是对"表现层"的描述。

• 状态转化（State Transfer）

　　访问一个网站，就代表了客户端和服务器的一个互动过程。在这个过程中，势必涉及到数据和状态的变化。

　　互联网通信协议HTTP协议，是一个无状态协议。这意味着，所有的状态都保存在服务器端。因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发生"状态转化"（State Transfer）。而这种转化是建立在表现层之上的，所以就是"表现层状态转化"。

　　客户端用到的手段，只能是HTTP协议。具体来说，就是HTTP协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。它们分别对应四种基本操作：GET用来获取资源，POST用来新建资源（也可以用于更新资源），PUT用来更新资源，DELETE用来删除资源

以上引用：阮一峰 理解restful架构

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

经过3天研究发现restful很有意思，同时，我基本上填坑的，我是用go + PostgreSQL 语言写的，go我不是太会，PostgreSQL我从来没用过。本来是个很简单的玩意，硬是花了3天。go真心不好调试。

go RESTful 库：https://github.com/ant0ine/go-json-rest

go postgreSql driver: https://github.com/go-pg/pg

主要参考的就是这个例子：

 package main

 import (
     "fmt"
     "github.com/ant0ine/go-json-rest/rest"
     "log"
     "net/http"
     "sync"
 )

 func main() {

     users := Users{
         Store: map[string]*User{},
     }

     api := rest.NewApi()
     api.Use(rest.DefaultDevStack...)
     router, err := rest.MakeRouter(
         rest.Get("/users", users.GetAllUsers),
         rest.Post("/users", users.PostUser),
         rest.Get("/users/:id", users.GetUser),
         rest.Put("/users/:id", users.PutUser),
         rest.Delete("/users/:id", users.DeleteUser),
     )
     if err != nil {
         log.Fatal(err)
     }
     api.SetApp(router)
     log.Fatal(http.ListenAndServe(":8080", api.MakeHandler()))
 }

 type User struct {
     Id   string
     Name string
 }

 type Users struct {
     sync.RWMutex
     Store map[string]*User
 }

 func (u *Users) GetAllUsers(w rest.ResponseWriter, r *rest.Request) {
     u.RLock()
     users := make([]User, len(u.Store))
     i :=
     for _, user := range u.Store {
         users[i] = *user
         i++
     }
     u.RUnlock()
     w.WriteJson(&users)
 }

 func (u *Users) GetUser(w rest.ResponseWriter, r *rest.Request) {
     id := r.PathParam("id")
     u.RLock()
     var user *User
     if u.Store[id] != nil {
         user = &User{}
         *user = *u.Store[id]
     }
     u.RUnlock()
     if user == nil {
         rest.NotFound(w, r)
         return
     }
     w.WriteJson(user)
 }

 func (u *Users) PostUser(w rest.ResponseWriter, r *rest.Request) {
     user := User{}
     err := r.DecodeJsonPayload(&user)
     if err != nil {
         rest.Error(w, err.Error(), http.StatusInternalServerError)
         return
     }
     u.Lock()
     id := fmt.Sprintf("%d", len(u.Store)) // stupid
     user.Id = id
     u.Store[id] = &user
     u.Unlock()
     w.WriteJson(&user)
 }

 func (u *Users) PutUser(w rest.ResponseWriter, r *rest.Request) {
     id := r.PathParam("id")
     u.Lock()
     if u.Store[id] == nil {
         rest.NotFound(w, r)
         u.Unlock()
         return
     }
     user := User{}
     err := r.DecodeJsonPayload(&user)
     if err != nil {
         rest.Error(w, err.Error(), http.StatusInternalServerError)
         u.Unlock()
         return
     }
     user.Id = id
     u.Store[id] = &user
     u.Unlock()
     w.WriteJson(&user)
 }

 func (u *Users) DeleteUser(w rest.ResponseWriter, r *rest.Request) {
     id := r.PathParam("id")
     u.Lock()
     delete(u.Store, id)
     u.Unlock()
     w.WriteHeader(http.StatusOK)
 }

这里有个巨坑，找了好久才发现：

 type User struct {
     Id   string
     Name string
 }

这些变量必须大写，如果小写的，程序不会报错，但是没有结果。（我对json不太会，估计是这个问题）

还有就是go 封装的PostgreSQL driver,我已无力吐槽，API明显不给力，写的SQL各种出错，但是不知道错误原因，硬是各种看SQL怎么错了。