使用Go构建RESTful的JSON API

最新推荐文章于 2022-05-08 22:54:00 发布
最新推荐文章于 2022-05-08 22:54:00 发布
阅读量717 收藏
点赞数
分类专栏： 备忘

原文地址http://thenewstack.io/make-a-restful-json-api-go/ 
这篇文章不仅仅讨论如何使用Go构建RESTful的JSON API，同时也会讨论如何设计好的RESTful API。如果你曾经遭遇了未遵循良好设计的API，那么你最终将写烂代码来使用这些垃圾API。希望阅读这篇文章后，你能够对好的API应该是怎样的有更多的认识。

JSON API是啥？

在JSON前，XML是一种主流的文本格式。笔者有幸XML和JSON都使用过，毫无疑问，JSON是明显的赢家。本文不会深入涉及JSON API的概念，在jsonapi.org可以找到的详细的描述。

Sponsor Note

SpringOne2GX是一个专门面向App开发者、解决方案和数据架构师的会议。议题都是专门针对程序猿（媛），架构师所使用的流行的开源技术，如：Spring IO Projects，Groovy & Grails，Cloud Foundry，RabbitMQ，Redis，Geode，Hadoop and Tomcat等。

一个基本的Web Server

一个RESTful服务本质上首先是一个Web service。下面的是示例是一个最简单的Web server，对于任何请求都简单的直接返回请求链接：

package main

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

func main() {
        http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
            fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
    })

    log.Fatal(http.ListenAndServe(":8080", nil))
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

编译执行这个示例将运行这个server，监听8080端口。尝试使用http://localhost:8080访问server。

增加一个路由

当大多数标准库开始支持路由，我发现大多数人都搞不清楚它们是如何工作的。我在项目中使用过几个第三方的router。印象最深的是Gorilla Web Toolkit中的mux router.

另一个比较流行的router是Julien Schmidt贡献的httprouter

package main

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

        "github.com/gorilla/mux"
)

func main() {
        router := mux.NewRouter().StrictSlash(true)
        router.HandleFunc("/", Index)
        log.Fatal(http.ListenAndServe(":8080", router))
}

func Index(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

运行上面的示例，首先需要安装包“github.com/gorilla/mux”.可以直接使用命令go get遍历整个source code安装所有未安装的依赖包。

译者注：

也可以使用go get "github.com/gorilla/mux"直接安装包。

上面的示例创建了一个简单的router，增加了一个“/”路由，并分配Index handler响应针对指定的endpoint的访问。这是你会发现在第一个示例中还能访问的如http://localhost:8080/foo这类的链接在这个示例中不再工作了，这个示例将只能响应链接http://localhost:8080.

创建更多的基本路由

上一节我们已经有了一个路由，是时候创建更多的路由了。假设我们将要创建一个基本的TODO app。

package main

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

    "github.com/gorilla/mux"
)

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 Index(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Welcome!")
}

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

func TodoShow(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    todoId := vars["todoId"]
    fmt.Fprintln(w, "Todo show:", todoId)
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

现在我们又在上一个示例的基础上增加了两个routes，分别是：

这就是一个RESTful设计的开始。注意，最后一个路由我们增加了一个名为todoId的变量。这将允许我们向route传递变量，然后获得合适的响应记录。

基本样式

有了路由后，就可以创建一些基本的TODO样式用于发送和检索数据。在一些其他语言中使用类（class）来达到这个目的，Go中使用struct。

package main

import “time”

type Todo struct {
    Name        string
    Completed   tool
    Due         time.time
}

type Todos []Todo
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

注：

最后一行定义的类型Todos是Todo的slice。稍后你将会看到怎么使用它。

返回JSON

基于上面的基本样式，我们可以模拟真实的响应，并基于静态数据列出TodoIndex。

func TodoIndex(w http.ResponseWriter, r *http.Request) {
    todos := Todos{
    Todo{Name: "Write presentation"},
    Todo{Name: "Host meetup"},
    }

    json.NewEncoder(w).Encode(todos)
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

这样就创建了一个Todos的静态slice，并被编码响应用户请求。如果这时你访问http://localhost:8080/todos，你将得到如下响应：

[
    {
        "Name": "Write presentation",
        "Completed": false,
        "Due": "0001-01-01T00:00:00Z"
    },
    {
    "Name": "Host meetup",
        "Completed": false,
        "Due": "0001-01-01T00:00:00Z"
    }
]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

一个稍微好点的样式

可能你已经发现了，基于前面的样式，todos返回的并不是一个标准的JSON数据包（JSON格式定义中不包含大写字母）。虽然这个问题有那么一点微不足道，但是我们还是可以解决它：

package main

import "time"

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

type Todos []Todo
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

上面的代码示例在原来的基础上增加了struct tags，这样可以指定JSON的编码格式。

文件拆分

到此我们需要对这个项目稍微做下重构。现在一个文件包含了太多的内容。我们将创建如下几个文件，并重新组织文件内容：

  • main.go
  • handlers.go
  • routes.go
  • todo.go

handlers.go

package main

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

    "github.com/gorilla/mux"
)

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"},
    }

    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)
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

routes.go

package main

import (
    "net/http"

    "github.com/gorilla/mux"
)

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

type Routes []Route

func NewRouter() *mux.Router {

    router := mux.NewRouter().StrictSlash(true)
    for _, route := range routes {
        router.
        Methods(route.Method).
            Path(route.Pattern).
            Name(route.Name).
            Handler(route.HandlerFunc)
    }

    return router
}

var routes = Routes{
    Route{
        "Index",
        "GET",
        "/",
        Index,
    },
    Route{
        "TodoIndex",
        "GET",
        "/todos",
        TodoIndex,
    },
    Route{
        "TodoShow",
        "GET",
        "/todos/{todoId}",
        TodoShow,
    },
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

todo.go

package main

import "time"

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

type Todos []Todo
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

main.go

package main

import (
        "log"
        "net/http"
)

func main() {

    router := NewRouter()

    log.Fatal(http.ListenAndServe(":8080", router))
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

更好的路由

上面重构的一部分就是创建了一个更详细的route文件，新文件中使用了一个struct包含了更多的有关路由的详细信息。尤其是，我们可以通过这个struct指定请求的动作，如GET、POST、DELETE等。

记录Web Log

前面的拆分文件中，我还有一个更长远的考虑。稍后你将会看到，拆分后我将能够很轻松的使用其他函数装饰我的http handlers。这一节我们将使用这个功能让我们的web能够像其他现代的网站一样为web访问请求记Log。在Go中，目前还没有一个web logging package，也没有标准库提供相应的功能。所以我们不得不自己实现一个。

在前面拆分文件的基础上，我们创建一个叫logger.go的新文件，并在文件中添加如下代码：

package main

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

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(
            "%s\t%s\t%s\t%s",
            r.Method,
            r.RequestURI,
            name,
            time.Since(start),
        )
    })
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

这样，如果你访问http://localhost:8080/todos，你将会看到console中有如下log输出。

2014/11/19 12:41:39 GET /todos  TodoIndex       148.324us
  • 1
  • 2

Routes file开始疯狂…继续重构

基于上面的拆分，你会发现继续照着这个节奏发展，routes.go文件将变得越来越庞大。所以我们继续拆分这个文件。将其拆分为如下两个文件：

  • router.go
  • routes.go

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{
        "Index",
        "GET",
        "/",
        Index,
    },
    Route{
        "TodoIndex",
        "GET",
        "/todos",
        TodoIndex,
    },
    Route{
        "TodoShow",
        "GET",
        "/todos/{todoId}",
        TodoShow,
    },
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

router.go

package main

import (
    "net/http"

    "github.com/gorilla/mux"
)

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
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

做更多的事情

现在我们已经有了一个不错的模板，是时候重新考虑我们handlers了，让handler能做更多的事情。首先我们在TodoIndex中增加两行代码。

func TodoIndex(w http.ResponseWriter, r *http.Request) {
    todos := Todos{
        Todo{Name: "Write presentation"},
        Todo{Name: "Host meetup"},
    }

    w.Header().Set("Content-Type", "application/json; charset=UTF-8")
    w.WriteHeader(http.StatusOK)
    if err := json.NewEncoder(w).Encode(todos); err != nil {
        panic(err)
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

新增的两行代码让TodoIndex handler多做两件事。首先返回client期望的json，并告知内容类型。然后明确的设置一个状态码。

Go的net/http server在Header中没有显示的说明内容类型时将尝试为我们猜测内容类型，但是并不是总是那么准确。所以在我们知道content类型的情况下，我们应该总是自己设置类型。

等等，数据库在哪儿？

如果我们继续构造RESTful API，我们需要考虑一个地方用于存储和检索数据。但是这超出了本文所讨论的范畴，所以这里简单的实现了一个粗糙的数据存储（粗糙到甚至都没线程安全机制）。

创建一个名为repo.go的文件，代码如下：

package main

import "fmt"

var currentId int

var todos Todos

// Give us some seed data
func init() {
    RepoCreateTodo(Todo{Name: "Write presentation"})
    RepoCreateTodo(Todo{Name: "Host meetup"})
}

func RepoFindTodo(id int) Todo {
    for _, t := range todos {
        if t.Id == id {
            return t
        }
    }
    // return empty Todo if not found
    return Todo{}
}

func RepoCreateTodo(t Todo) Todo {
    currentId += 1
    t.Id = currentId
    todos = append(todos, t)
    return t
}

func RepoDestroyTodo(id int) error {
    for i, t := range todos {
        if t.Id == id {
            todos = append(todos[:i], todos[i+1:]...)
            return nil
        }
    }
    return fmt.Errorf("Could not find Todo with id of %d to delete", id)
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

为Todo添加一个ID

现在我们已经有了一个粗糙的数据库。我们可以为Todo创建一个ID，用于标识和见识Todo item。数据结构更新如下：

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
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

更新TodoIndex handler

数据存储在数据库后，不必在handler中生成数据，直接通过ID检索数据库即可得到相应内容。修改handler如下：

func TodoIndex(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json; charset=UTF-8")
    w.WriteHeader(http.StatusOK)
    if err := json.NewEncoder(w).Encode(todos); err != nil {
        panic(err)
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

Posting JSON

前面所有的API都是相应GET请求的，只能输出JSON。这节将增加一个上传和存储JSON的API。在routes.go文件中增加如下route：

Route{
    "TodoCreate",
    "POST",
    "/todos",
    TodoCreate,
},
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

The Create endpoint

上面创建了一个新的router，现在为这个新的route创建一个endpoint。在handlers.go文件增加TodoCreate handler。代码如下：

func TodoCreate(w http.ResponseWriter, r *http.Request) {
    var todo Todo
    body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
    if err != nil {
        panic(err)
    }
    if err := r.Body.Close(); err != nil {
        panic(err)
    }
    if err := json.Unmarshal(body, &todo); err != nil {
        w.Header().Set("Content-Type", "application/json;   charset=UTF-8")
        w.WriteHeader(422) // unprocessable entity
        if err := json.NewEncoder(w).Encode(err); err != nil {
            panic(err)
        }
    }

    t := RepoCreateTodo(todo)
    w.Header().Set("Content-Type", "application/json;   charset=UTF-8")
    w.WriteHeader(http.StatusCreated)
    if err := json.NewEncoder(w).Encode(t); err != nil {
        panic(err)
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

上面的代码中，首先我们获取用户请求的body。注意，在获取body时我们使用了io.LimitReader，这是一个防止你的服务器被恶意攻击的好方法。试想如果有人给你发送了一个500GB的json。

读取body后，将其内容解码到Todo struct中。如果解码失败，我们要做的事情不仅仅是返回一个‘422’这样的状态码，同时还会返回一段包含错误信息的json。这能够使客户端不仅知道有错误发生，还能了解错误发生在哪儿。

最后，如果一切顺利，我们将向客户端返回状态码201，同时我们还向客户端返回创建的实体内容，这些信息客户端在后面的操作中可能会用到。

Post JSON

所有的工作的完成后，我们就可以上传下json string测试一下了。Sample及返回结果如下所示：

curl -H "Content-Type: application/json" -d '{"name":"New Todo"}' http://localhost:8080/todos
Now, if you go to http://localhost/todos we should see the following response:
[
    {
        "id": 1,
        "name": "Write presentation",
        "completed": false,
        "due": "0001-01-01T00:00:00Z"
    },
    {
        "id": 2,
        "name": "Host meetup",
        "completed": false,
        "due": "0001-01-01T00:00:00Z"
    },
    {
        "id": 3,
        "name": "New Todo",
        "completed": false,
        "due": "0001-01-01T00:00:00Z"
    }
]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

我们未做的事情

现在我们已经有了一个好的开头，后面还有很多事情要做。下面是我们还未做的事情：

  • 版本控制 - 如果我们需要修改API，并且这将导致重大的更改？也许我们可以从为所有的routes添加/v1这样的前缀开始。
  • 身份认证 - 除非这是一个自由/公开的API，否则我们可能需要添加一些认证机制。建议学习JSON web tokens
  • eTags - 如果你的构建需要扩展，你可能需要实现eTags

还剩些啥？

所有的项目都是开始的时候很小，但是很快就会发展开始变得失控。如果我想把这件事带到下一个层级，并准备使其投入生产，则还有如下这些额外的事情需要做：

  • 很多的重构
  • 将这些文件封装成一些package，如JSON helpers，decorators，handlers等等。
  • 测试…是的，这个不能忽略。目前我们还没有做任何的测试，但是对于一个产品，这个是必须的。

如何获取源代码

如果你想获取本文示例的源代码，repo地址在这里：https://github.com/corylanou/tns-restful-json-api

hehe_heh
关注
专栏目录
go-json-rest框架实现Golang Restful API项目的开发
05-08
使用go-json-rest框架实现Golang Restful API项目的开发
go restful 安全_Go语言RESTful JSON API创建
weixin_39958911的博客
12-18 164
Go语言开发RESTFul JSON APIRESTful API在Web项目开发中广泛使用，本文针对Go语言如何一步步实现RESTful JSON API进行讲解， 另外也会涉及到RESTful设计方面的话题。也许我们之前有使用过各种各样的API, 当我们遇到设计很糟糕的API的时候，简直感觉崩溃至极。希望通过本文之后，能对设计良好的RESTful API有一个初步认识。JSON API是什么?...
组件分享之后端组件——轻松构建RESTful JSON API的组件go-json-rest
CN華少的博客
05-08 252
组件分享之后端组件——轻松构建RESTful JSON API的组件go-json-rest 背景 近期正在探索前端、后端、系统端各类常用组件与工具，对其一些常见的组件进行再次整理一下，形成标准化组件专题，后续该专题将包含各类语言中的一些常用组件。欢迎大家进行持续关注。 组件基本信息 组件：go-json-rest 开源协议：MIT license 内容 本节我们分享一个轻松构建RESTf...
详解Go语言RESTful JSON API创建
09-20
在Go语言中创建RESTful JSON API是Web服务开发中的常见任务。RESTful API遵循Representational State Transfer（表述性状态转移）原则，通过HTTP协议提供资源交互接口，而JSON（JavaScript Object Notation）作为...
go-json-rest：设置RESTful JSON API的快速简便方法
02-20
Go-Json-Rest是net/http之上的一薄层，可帮助轻松构建RESTful JSON API。 它使用基于Trie的实现提供快速且可扩展的请求路由，帮助处理JSON请求和响应的助手以及用于CORS，Auth，Gzip，Status等功能的中间件... 表中...
vendor:基于Go语言构建RESTful API服务器源码-vendor目录
03-23
在本文中，我们将深入探讨如何使用Go语言构建RESTful API服务器，并特别关注"vendor"目录在Go项目中的作用。RESTful API是Web服务设计的一种流行模式，它通过HTTP协议提供可预测、模块化的接口，使得客户端能够以...
Golang中使用 JWT认证来 保障Restful JSON API的安全（英文） - 推酷
11-22
本文将详细介绍如何使用Golang和JSON Web Tokens (JWT) 来构建安全的RESTful JSON API，并探讨JWT的基本原理以及其在Golang中的实现方法。 #### JSON Web Token (JWT) 的概念 JSON Web Token (JWT) 是一种紧凑且...
基于 Go 语言构建企业级的 RESTful API 服务.pdf
03-04
### 基于 Go 语言构建企业级的 RESTful API 服务 #### 一、概述 本文档旨在介绍如何利用 Go 语言构建一个稳定、高效的企业级 RESTful API 服务。Go 语言以其简洁的语法、强大的并发能力及内置的 HTTP 服务器库等...
Go-go-json-rest一种快速和容易的方式来搭建一个RESTfulJSONAPI
08-13
go-json-rest提供一种在Go语言中快速和容易的方式来搭建一个RESTful JSON API
Restful API 生成复杂Json数据结构及使用客户端解析该数据结构(三)
build2024
05-22 1315
一.返回简单Json结构 二.解析简单Json结构 三.返回复杂Json结构 四.解析复杂Json结构 前提说明：首先约定接口之前，需要约定接口的参数，接口参数包括输入参数和输出参数 输入参数：指接口调用时输入的参数 输出参数：即接口调用时返回的参数。 那么如果说，约定输入输出参数均需要采用Json结构，如果约定好输出参数为主从表关系，则需要采用Json嵌套数组结构返回。 来，下面举个例子： 一.返回简单Json结构 接口格式 { "Id":789456139, "TaskTy.
go restful json api
itegel的专栏
09-14 973
入门不错 http://thenewstack.io/make-a-restful-json-api-go/
php实现restful风格的json接口,restful风格API
weixin_39941262的博客
03-11 442
一、什么是API？API(Application Programming Interface,应用程序编程接口)是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。——百度百科简单来说就是：别人写好代码，编译号程序，可以让其他人调用使用，就称作API。你使用了别人代码(或者程序)中的某个函数、类、对象，就叫做使用了...
RESTful API
Auhiak的博客
08-27 574
一、REST REST（Representational State Transfer,翻译为“表现层状态转化”）是所有Web应用开发都应该遵守的架构设计指导原则。 面向资源是REST最明显的特征，对于同一个资源的一组不同操作。资源是服务器上一个可命名的抽象概念，资源是以名词为核心来组织的。 REST要求，必须通过统一的接口来对资源执行各种操作，对于每个资源只能执行...
php实现restful风格的json接口,编写 JSON API —— RESTful 风格 API 设计原则与最佳实践...
weixin_28729331的博客
03-11 327
编写 JSON API —— RESTful 风格 API 设计原则与最佳实践由 学院君 创建于1年前, 最后更新于 1年前版本号 #19524 views9 likes2 collects概述在移动互联网时代，Laravel 开发者日常接触最多的任务应该就是编写 JSON API 接口，基于 RESTful 风格或类 RESTful 风格，以便允许第三方应用/客户端应用与后台应用通过这些 API...
微服务下基于RESTFUL风格实现统一的接口设计(JSON API)
weixin_41756573的博客
07-26 2846
RESTFUL JSON APIJSON API解决的问题服务架构参考文档效果展示返回单个对象返回集合对象名词解析实现步骤相关技术栈需求简述项目结构简图统一的依赖管理POMRESTFUL JSON API 项目搭建POMapplicationapplication.yml核心代码核心代码的关系图 JSON API 解决的问题 在微服务架构下，前后端分离的项目如何通过统一的数据结构进行数据交互。 服务架构 适用范围：微服务架构 + 前后端分离 参考文档 JSON API中文版 JSON API官方英文版 效果
Go语言RESTful JSON API创建
weixin_34417200的博客
05-16 114
Go语言开发RESTFul JSON API RESTful API在Web项目开发中广泛使用，本文针对Go语言如何一步步实现RESTful JSON API进行讲解， 另外也会涉及到RESTful设计方面的话题。 也许我们之前有使用过各种各样的API, 当我们遇到设计很糟糕的API的时候，简直感觉崩溃至极。希望通过本文之后，能对设计良...
SpringMVC---初识、Restful风格、JSON
qq_47840823的博客
03-07 688
1.MVC 1.1MVC概念： 模型(Model)、视图(View)、控制器(Controller)，是一种软件设计规范。 将业务逻辑、数据、显示分离的方法来组织代码。 MVC主要作用是降低了视图与业务逻辑间的双向偶合。 MVC不是一种设计模式，MVC是一种架构模式；当然不同的MVC存在差异。   三层： Model（模型）：数据模型，包含数据和行为，一般都分离开来即 Value Object（数据Dao）和 服务层（行 为Service）。也就是模型提供了模型数据查询和模型数据的状态更新
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值