为什么我选择“golly”框架来构建我的下一个基于 Golang 的 REST API？

get /api/v1/users
post /api/v1/users
put /api/v1/users/:id
delete /api/v1/users/:id

mkdir my-go-server
cd my-go-server
go mod init rest_server

go get oss.nandlabs.io/golly

package main

import "rest_server/server"

func main() {
        // create the instance of your server
    srv := server.newserver()
        // start your server
    srv.start()
}

package server

import (
    "rest_server/handlers"
    "rest_server/store"

    "oss.nandlabs.io/golly/lifecycle"
    "oss.nandlabs.io/golly/rest/server"
)

type server struct {
    store *store.store
}

func newserver() *server {
    return &server{
        store: store.newstore(),
    }
}

func (s *server) start() {
    // register the router by creating the server object
    restserver, err := server.default()
    if err != nil {
        panic(err)
    }

    // add path prefix if you want
    restserver.opts().pathprefix = "/api/v1"

    // register routes
    restserver.get("/users", handlers.getusers)
    restserver.post("/users", handlers.adduser)
    restserver.put("/users/:id", handlers.updateuser)
    restserver.delete("/users/:id", handlers.deleteuser)

    // create the http.server object and register the router as handler
    // provide the necessary configurations such as port, readtimeout, writetimeout...
    manager := lifecycle.newsimplecomponentmanager()

    // register the server
    manager.register(restserver)

    // start the server
    manager.startandwait()
}

package store

import "rest_server/models"

type store struct {
    data map[string]models.item
}

var initstore *store

func newstore() *store {
    initstore = &store{data: make(map[string]models.item)}
    return initstore
}

func getstore() *store {
    return initstore
}

func (s *store) getall() []models.item {
    items := []models.item{}
    for _, item := range s.data {
        items = append(items, item)
    }
    return items
}

func (s *store) getbyid(id string) (item models.item, exists bool) {
    item, exists = s.data[id]
    return
}

func (s *store) put(id string, item models.item) {
    s.data[id] = item
}

func (s *store) delete(id string) {
    delete(s.data, id)
}

package models

type item struct {
    id    string `json:"id"`
    value string `json:"value"`
}

package handlers

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

    "rest_server/models"
    "rest_server/response"
    "rest_server/store"

    "oss.nandlabs.io/golly/rest/server"
    "oss.nandlabs.io/golly/uuid"
)

func adduser(ctx server.context) {
    // create the model type variable
    var item models.item
    // decode the request body to the item reference
    if err := json.newdecoder(ctx.getrequest().body).decode(&item); err != nil {
        // in case of error write the error to the response and return
        response.error(ctx.httpreswriter(), http.statusbadrequest, "invalid request payload")
        return
    }

    // get the store object 
    initstore := store.getstore()

    uuid, err := uuid.v1()
    if err == nil {
        // assign the uuid generated to the item
        item.id = uuid.string()
        // add the input body item to the store
        initstore.put(item.id, item)
        // generate a success response
        response.json(ctx.httpreswriter(), http.statuscreated, item)
    } else {
        // generate the error response
        response.error(ctx.httpreswriter(), http.statusbadrequest, "error generating uuid")
        return
    }
}

cd /my-go-server

go run main.go