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 := 0
    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怎么错了。