restgo

package module
v0.0.0-...-8787768 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 21, 2016 License: MIT Imports: 9 Imported by: 4

README

Router for api server of golang, on the top of fasthttp, inspired by expressjs, use it like expressjs.

GoDoc

Install

go get github.com/restgo/restgo

Url Pattern

/users
/users/:id
/categories/:category_id/posts/:id

URL Params will be encoded in querystring, you can get values from querystring or use ctx.ParamXXX methods to get it.

for url: /users/12345?limit=10&page=2&sort=

ctx.ParamString("id", "")   // get "12345" 
ctx.ParamInt("limit", 15)   // get 15
ctx.ParamInt("page", 1)     // get 2
ctx.ParamString("sort", "id")  // get "id", default value

Middleware

It's easy to develop a middleware for it

Such as log middleware

app.Use(func (ctx *Context, next restgo.Next) {
    fmt.Println("This is log middleware, I will log everything!")
    next(nil)
})

Session

Please check restgo/session

Use with Controller

type UserController struct {}

// implement ControllerRouter Interface, then you can set route for this controller
func (this *UserController)Route(router *restgo.Router) {
    router.GET("/", this.Get) // GET /users/
}

func (this *UserController) Get(ctx *Context, next restgo.Next) {
    ctx.ServeText(200, "GET User")
}

// Add it to router
app.Use("/users", &UserController{});

//now, you can access it `GET /users/`, SIMPLE!!! 

Demo

check example exmaple/app.go

app := restgo.App()

// filter all request
app.Use(func(ctx *Context, next restgo.Next) {
    fmt.Println("Filter all")
    next(nil)
})

// load controller route
app.Use("/users", &UserController{})

// all /test requests(GET, DELETE, PUT...) go into this handler
app.All("/test", func(ctx *Context, next restgo.Next) {
    fmt.Println("All test: " + string(ctx.Method()))
    ctx.ServeText(200, "All test: "+string(ctx.Method()))
})

// set /about path handler
app.GET("/about", func(ctx *Context, next restgo.Next) {
    fmt.Println("GET about")
    ctx.ServeText(200, "GET about")
})

// default :8080, you can specify it too. app.Run(":8080")
app.Run()

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Context

type Context struct {
	*fasthttp.RequestCtx
	*render.Render
}

func (*Context) ParamFloat

func (this *Context) ParamFloat(key string, defVal float64) float64

Get path parameter or query parameter as float64. if not exist, default value will be returned

func (*Context) ParamInt

func (this *Context) ParamInt(key string, defVal int) int

Get path parameter or query parameter as int. if not exist, default value will be returned

func (*Context) ParamString

func (this *Context) ParamString(key string, defVal string) string

Get path parameter or query parameter as string. if not exist, default value will be returned

func (*Context) ServeData

func (this *Context) ServeData(status int, v []byte) error

func (*Context) ServeError

func (this *Context) ServeError(status int, err error) error

func (*Context) ServeHTML

func (this *Context) ServeHTML(status int, name string, binding interface{}, layout ...string) error

func (*Context) ServeJSON

func (this *Context) ServeJSON(status int, v interface{}) error

func (*Context) ServeJSONP

func (this *Context) ServeJSONP(status int, callback string, v interface{}) error

func (*Context) ServeText

func (this *Context) ServeText(status int, v string) error

func (*Context) ServeXML

func (this *Context) ServeXML(status int, v interface{}) error

type ControllerRouter

type ControllerRouter interface {
	Route(*Router)
}

controller implement this interface to init router for it

type HTTPHandler

type HTTPHandler func(ctx *Context, next Next)

type JSON

type JSON map[string]interface{}

type Next

type Next func(err error)

type Restgo

type Restgo struct {
	// contains filtered or unexported fields
}

func App

func App(renderConfig ...*render.Config) *Restgo

create app instance, give render config or use default(pass nothing) lean how to config render here : https://github.com/unrolled/render

func (*Restgo) All

func (this *Restgo) All(path string, handlers ...HTTPHandler) *Router

set handlers for all types requests

func (*Restgo) DELETE

func (this *Restgo) DELETE(path string, handlers ...HTTPHandler) *Router

set handlers for `DELETE` request

func (*Restgo) GET

func (this *Restgo) GET(path string, handlers ...HTTPHandler) *Router

set handlers for `GET` request

func (*Restgo) HEAD

func (this *Restgo) HEAD(path string, handlers ...HTTPHandler) *Router

set handlers for `HEAD` request

func (*Restgo) OPTIONS

func (this *Restgo) OPTIONS(path string, handlers ...HTTPHandler) *Router

set handlers for `OPTIONS` request

func (*Restgo) PATCH

func (this *Restgo) PATCH(path string, handlers ...HTTPHandler) *Router

set handlers for `PATCH` request

func (*Restgo) POST

func (this *Restgo) POST(path string, handlers ...HTTPHandler) *Router

set handlers for `POST` request

func (*Restgo) PUT

func (this *Restgo) PUT(path string, handlers ...HTTPHandler) *Router

set handlers for `PUT` request

func (*Restgo) Route

func (this *Restgo) Route(path string) *Route

create a sub-route

func (*Restgo) Router

func (this *Restgo) Router(renderConfig ...*render.Config) *Router

create a new router

func (*Restgo) Run

func (this *Restgo) Run(addr ...string)

run app on address `addr` or default `:8080`. only first addr will be used in the parameters.

func (*Restgo) Use

func (this *Restgo) Use(handlers ...interface{}) *Router

set handlers for `path`, default is `/`. you can use it as filters

type Route

type Route struct {
	// contains filtered or unexported fields
}

func (*Route) All

func (this *Route) All(handlers ...HTTPHandler) *Route

all types requests will go into registered handler

func (*Route) DELETE

func (this *Route) DELETE(handlers ...HTTPHandler) *Route

register handlers for `DELETE` request

func (*Route) GET

func (this *Route) GET(handlers ...HTTPHandler) *Route

register handlers for `GET` request

func (*Route) HEAD

func (this *Route) HEAD(handlers ...HTTPHandler) *Route

register handlers for `HEAD` request

func (*Route) HTTPHandler

func (this *Route) HTTPHandler(ctx *Context, done Next)

implement HTTPHandle interface, so you can use it as a handler

func (*Route) OPTIONS

func (this *Route) OPTIONS(handlers ...HTTPHandler) *Route

register handlers for `OPTIONS` request

func (*Route) PATCH

func (this *Route) PATCH(handlers ...HTTPHandler) *Route

register handlers for `PATCH` request

func (*Route) POST

func (this *Route) POST(handlers ...HTTPHandler) *Route

register handlers for `POST` request

func (*Route) PUT

func (this *Route) PUT(handlers ...HTTPHandler) *Route

register handlers for `PUT` request

type Router

type Router struct {
	// contains filtered or unexported fields
}

func NewRouter

func NewRouter(renderConfig ...*render.Config) *Router

Create one new Router

func (*Router) All

func (this *Router) All(path string, handlers ...HTTPHandler) *Router

set handlers for all types requests

func (*Router) DELETE

func (this *Router) DELETE(path string, handlers ...HTTPHandler) *Router

set handlers for `DELETE` request

func (*Router) FastHttpHandler

func (this *Router) FastHttpHandler(ctx *fasthttp.RequestCtx)

implement fasthttp.RequestHandler function

func (*Router) GET

func (this *Router) GET(path string, handlers ...HTTPHandler) *Router

set handlers for `GET` request

func (*Router) HEAD

func (this *Router) HEAD(path string, handlers ...HTTPHandler) *Router

set handlers for `HEAD` request

func (*Router) HTTPHandler

func (this *Router) HTTPHandler(ctx *Context, next Next)

implement HTTPHandler interface, make it can be as a handler

func (*Router) OPTIONS

func (this *Router) OPTIONS(path string, handlers ...HTTPHandler) *Router

set handlers for `OPTIONS` request

func (*Router) PATCH

func (this *Router) PATCH(path string, handlers ...HTTPHandler) *Router

set handlers for `PATCH` request

func (*Router) POST

func (this *Router) POST(path string, handlers ...HTTPHandler) *Router

set handlers for `POST` request

func (*Router) PUT

func (this *Router) PUT(path string, handlers ...HTTPHandler) *Router

set handlers for `PUT` request

func (*Router) Route

func (this *Router) Route(path string) *Route

create a sub-route

func (*Router) Use

func (this *Router) Use(handlers ...interface{}) *Router

set handlers for `path`, default is `/`. you can use it as filters Use(handler) User("/user", userHandler)

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL