README
¶
SGo
SGo is a simple, light and fast Web framework written in Go.
The source is easy to learn, then you can make your own Go Web Framework!
Features
- Pretty and fast router - based on radix tree
- Middleware Support
- Friendly to REST API
- No regexp or reflect
- QUIC Support
- Inspired by many excellent Go Web framework
Installation
go get github.com/AmyangXYZ/sgo
Example
Simple
package main
import (
"github.com/AmyangXYZ/sgo"
)
func main() {
app := sgo.New()
app.GET("/", func(ctx *sgo.Context) error {
return ctx.Text(200, "Hello")
})
app.Run(":16311")
}
Further
For vue2 projects, add module.exports = {assetsDir: 'static', css: { extract: false }} to vue.config.js, then npm run build && tar caf dist.tar.xz dist and copy dist.tar.xz and run ./deployFrontend.sh.
package main
import (
"encoding/json"
"errors"
"fmt"
"io/ioutil"
"log"
"net/http"
"github.com/AmyangXYZ/sgo"
"github.com/gorilla/websocket"
)
const (
addr = ":8888"
)
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
func main() {
app := sgo.New()
app.SetTemplates("./templates", nil)
app.GET("/", index)
app.GET("/static/*files", static)
app.GET("/api/boottime", getBootTime)
app.GET("/ws/comm", wsComm)
app.POST("/api/link/:name", postHandler)
app.OPTIONS("/api/link/:name", sgo.PreflightHandler)
if err := app.Run(addr); err != nil {
log.Fatal("Listen error", err)
}
}
// Index page handler.
func index(ctx *sgo.Context) error {
return ctx.Render(200, "index")
}
// Static files handler.
func static(ctx *sgo.Context) error {
staticHandle := http.StripPrefix("/static",
http.FileServer(http.Dir("./static")))
staticHandle.ServeHTTP(ctx.Resp, ctx.Req)
return nil
}
func getBootTime(ctx *sgo.Context) error {
return ctx.Text(200, fmt.Sprintf("%d", 20))
}
func wsComm(ctx *sgo.Context) error {
ws, err := upgrader.Upgrade(ctx.Resp, ctx.Req, nil)
breakSig := make(chan bool)
if err != nil {
return err
}
fmt.Println("ws/comm connected")
defer func() {
ws.Close()
fmt.Println("ws/comm client closed")
}()
go func() {
for {
_, _, err := ws.ReadMessage()
if err != nil {
breakSig <- true
}
}
}()
for {
select {
// case l := <-LogsComm:
// ws.WriteJSON(l)
case <-breakSig:
return errors.New("stop ws")
}
}
}
func postHandler(ctx *sgo.Context) error {
// param request
fmt.Println(ctx.Params)
// json body request
body, err := ioutil.ReadAll(ctx.Req.Body)
if err != nil {
return err
}
fmt.Println(string(body))
var data map[string]interface{}
json.Unmarshal(body, &data)
return ctx.Text(200, "xx")
}
My Blog is also powered by SGo.
License
MIT
Documentation
¶
Index ¶
- Constants
- Variables
- func MethodNotAllowedHandler(ctx *Context) error
- func NotFoundHandler(ctx *Context) error
- type Context
- func (ctx *Context) Error(code int, error string)
- func (ctx *Context) FormFile(key string) (multipart.File, *multipart.FileHeader, error)
- func (ctx *Context) Get(key string) interface{}
- func (ctx *Context) GetCookie(name string) string
- func (ctx *Context) Gets() map[string]interface{}
- func (ctx *Context) Init(w http.ResponseWriter, r *http.Request)
- func (ctx *Context) JSON(code, flag int, msg string, data interface{}) error
- func (ctx *Context) JSONP(code int, callback string, data interface{}) error
- func (ctx *Context) Method() string
- func (ctx *Context) Next()
- func (ctx *Context) Param(key string) string
- func (ctx *Context) Params() url.Values
- func (ctx *Context) Path() string
- func (ctx *Context) Redirect(code int, url string)
- func (ctx *Context) Referer() string
- func (ctx *Context) Render(code int, tplname string) error
- func (ctx *Context) SaveFile(name, saveDir string) (string, error)
- func (ctx *Context) Set(key string, val interface{})
- func (ctx *Context) SetCookie(name, value string)
- func (ctx *Context) Status() int
- func (ctx *Context) Text(code int, body string) error
- func (ctx *Context) UserAgent() string
- func (ctx *Context) Write(data []byte) (n int, err error)
- type HandlerFunc
- type SGo
- func (sg *SGo) Any(path string, handler HandlerFunc)
- func (sg *SGo) CONNECT(path string, handler HandlerFunc)
- func (sg *SGo) DELETE(path string, handler HandlerFunc)
- func (sg *SGo) GET(path string, handler HandlerFunc)
- func (sg *SGo) HEAD(path string, handler HandlerFunc)
- func (sg *SGo) Handle(method, path string, handler HandlerFunc)
- func (sg *SGo) OPTIONS(path string, handler HandlerFunc)
- func (sg *SGo) PATCH(path string, handler HandlerFunc)
- func (sg *SGo) POST(path string, handler HandlerFunc)
- func (sg *SGo) PUT(path string, handler HandlerFunc)
- func (sg *SGo) Run(addr string) error
- func (sg *SGo) RunOverTLS(addr, certFile, keyFile string) error
- func (sg *SGo) ServeHTTP(w http.ResponseWriter, r *http.Request)
- func (sg *SGo) SetTemplates(tplDir string, funcMap template.FuncMap)
- func (sg *SGo) TRACE(path string, handler HandlerFunc)
- func (sg *SGo) USE(middlewares ...HandlerFunc)
- type Templates
- type Trie
Constants ¶
View Source
const ( CONNECT = http.MethodConnect DELETE = http.MethodDelete GET = http.MethodGet HEAD = http.MethodHead OPTIONS = http.MethodOptions PATCH = http.MethodPatch POST = http.MethodPost PUT = http.MethodPut TRACE = http.MethodTrace )
HTTP methods
Variables ¶
View Source
var PreflightHandler = func(ctx *Context) error { return ctx.Text(200, "") }
PreflightHandler is a dummy handler that handles preflight request when CORS
Functions ¶
func MethodNotAllowedHandler ¶
MethodNotAllowedHandler .
Types ¶
type Context ¶
type Context struct {
Req *http.Request
Resp *responseWriter
// contains filtered or unexported fields
}
Context provide a HTTP context for SGo.
func NewContext ¶
NewContext .
func (*Context) Init ¶
func (ctx *Context) Init(w http.ResponseWriter, r *http.Request)
Init the context gotten from sync pool.
type SGo ¶
type SGo struct {
// Router is based on a radix/trie tree.
Tree *Trie
// Pool is for context.
Pool *sync.Pool
NotFoundHandler HandlerFunc
MethodNotAllowedHandler HandlerFunc
// Built-in templates render.
Templates *Templates
Middlewares []HandlerFunc
}
SGo is Suuuuuuuuper Sweetie!
func (*SGo) Any ¶
func (sg *SGo) Any(path string, handler HandlerFunc)
Any register any method handler
func (*SGo) CONNECT ¶
func (sg *SGo) CONNECT(path string, handler HandlerFunc)
CONNECT register CONNECT request handler
func (*SGo) DELETE ¶
func (sg *SGo) DELETE(path string, handler HandlerFunc)
DELETE register DELETE request handler
func (*SGo) GET ¶
func (sg *SGo) GET(path string, handler HandlerFunc)
GET register GET request handler
func (*SGo) HEAD ¶
func (sg *SGo) HEAD(path string, handler HandlerFunc)
HEAD register HEAD request handler
func (*SGo) Handle ¶
func (sg *SGo) Handle(method, path string, handler HandlerFunc)
Handle register custom METHOD request HandlerFunc
func (*SGo) OPTIONS ¶
func (sg *SGo) OPTIONS(path string, handler HandlerFunc)
OPTIONS register OPTIONS request handler
func (*SGo) PATCH ¶
func (sg *SGo) PATCH(path string, handler HandlerFunc)
PATCH register PATCH request HandlerFunc
func (*SGo) POST ¶
func (sg *SGo) POST(path string, handler HandlerFunc)
POST register POST request handler
func (*SGo) PUT ¶
func (sg *SGo) PUT(path string, handler HandlerFunc)
PUT register PUT request handler
func (*SGo) RunOverTLS ¶
RunOverTLS .
func (*SGo) SetTemplates ¶
SetTemplates set the templates dir and funcMap.
func (*SGo) TRACE ¶
func (sg *SGo) TRACE(path string, handler HandlerFunc)
TRACE register TRACE request handler
type Templates ¶
type Templates struct {
Dir string
Suffix string
FuncMap template.FuncMap
// contains filtered or unexported fields
}
Templates is a templates manager.
func NewTemplates ¶
NewTemplates .
Source Files
¶
Directories
Click to show internal directories.
Click to hide internal directories.