hiboot: hidevops.io/hiboot/pkg/app/web Index | Examples | Files | Directories

package web

import "hidevops.io/hiboot/pkg/app/web"

Package web provides quick start framework for web application.

Main features of Hiboot web application

Web MVC (Model-View-Controller).

Auto Configuration, pre-created instance with properties configs for dependency injection.

Dependency injection with the struct tag `inject:""` or the constructor.

Dependency injection in Go

Dependency injection is a concept valid for any programming language. The general concept behind dependency injection is called Inversion of Control. According to this concept a struct should not configure its dependencies statically but should be configured from the outside.

Dependency Injection design pattern allows us to remove the hard-coded dependencies and make our application loosely coupled, extendable and maintainable.

A Go struct has a dependency on another struct, if it uses an instance of this struct. We call this a struct dependency. For example, a struct which accesses a user controller has a dependency on user service struct.

Ideally Go struct should be as independent as possible from other Go struct. This increases the possibility of reusing these struct and to be able to test them independently from other struct.

The following example shows a struct which has no hard dependencies.

This example shows that jwtToken is injected through method Init, once you imported "hidevops.io/hiboot/pkg/starter/jwt", jwtToken jwt.Token will be injectable.

Code:

package main

import (
    "hidevops.io/hiboot/pkg/app/web"
    "hidevops.io/hiboot/pkg/at"
    "hidevops.io/hiboot/pkg/model"
    "hidevops.io/hiboot/pkg/starter/jwt"
    "time"
)

// This example shows that jwtToken is injected through method Init,
// once you imported "hidevops.io/hiboot/pkg/starter/jwt",
// jwtToken jwt.Token will be injectable.
func main() {
    // the web application entry
    web.NewApplication(newLoginController).Run()
}

// PATH: /login
type loginController struct {
    at.RestController

    token jwt.Token
}

type userRequest struct {
    // embedded field model.RequestBody mark that userRequest is request body
    model.RequestBody
    Username string `json:"username" validate:"required"`
    Password string `json:"password" validate:"required"`
}

// newLoginController inject jwtToken through the argument jwtToken jwt.Token on constructor
// the dependency jwtToken is auto configured in jwt starter, see https://hidevops.io/hiboot/tree/master/pkg/starter/jwt
func newLoginController(token jwt.Token) *loginController {
    return &loginController{
        token: token,
    }
}

// Post /
// The first word of method is the http method POST, the rest is the context mapping
func (c *loginController) Post(request *userRequest) (response model.Response, err error) {
    jwtToken, _ := c.token.Generate(jwt.Map{
        "username": request.Username,
        "password": request.Password,
    }, 30, time.Minute)

    response = new(model.BaseResponse)
    response.SetData(jwtToken)

    return
}

Index

Examples

Package Files

application.go autoconfigure.go context.go controller.go defaultconfig.go dispatcher.go doc.go handler.go method_subscriber.go properties.go testapplication.go

Constants

const (
    Any             = "ANY"
    RequestMapping  = "RequestMapping"
    ContextPathRoot = "/"
    UrlSep          = "/"
)
const (
    // ViewEnabled is the property for enabling web view
    ViewEnabled = "web.view.enabled"
    // ContextPath is the property for setting web view context path
    ContextPath = "web.view.contextPath"
    // DefaultPage is the property for setting default page
    DefaultPage = "web.view.defaultPage"
    // ResourcePath is the property for setting resource path
    ResourcePath = "web.view.resourcePath"
    // Extension is the property for setting extension
    Extension = "web.view.extension"
)
const Profile = "web"

Variables

var (

    // ErrControllersNotFound controller not found
    ErrControllersNotFound = errors.New("[app] controllers not found")

    // ErrInvalidController invalid controller
    ErrInvalidController = errors.New("[app] invalid controller")
)
var (
    ErrCanNotInterface = errors.New("response can not interface")
)
var NewTestApplication = RunTestApplication

NewTestApplication is the alias of RunTestApplication Deprecated, you should use RunTestApplication instead

var RestController = app.Register

RestController register rest controller to controllers container Deprecated: please use app.Register() instead

func Handler Uses

func Handler(h func(context.Context)) iris.Handler

Handler will convert our handler of func(*Context) to an iris Handler, in order to be compatible with the HTTP API.

func NewApplication Uses

func NewApplication(controllers ...interface{}) app.Application

NewApplication create new web application instance and init it

func NewContext Uses

func NewContext(app ctx.Application) context.Context

NewContext constructor of context.Context

func RequestBody Uses

func RequestBody(c context.Context, data interface{}) error

RequestBody get RequestBody

func RequestForm Uses

func RequestForm(c context.Context, data interface{}) error

RequestForm get RequestFrom

func RequestParams Uses

func RequestParams(c context.Context, data interface{}) error

RequestParams get RequestParams

type Annotations Uses

type Annotations struct {
    Fields []*annotation.Field
    Object interface{}
    Value  reflect.Value
}

type Context Uses

type Context struct {
    iris.Context
}

Context Create your own custom Context, put any fields you wanna need.

func (*Context) HTML Uses

func (c *Context) HTML(htmlContents string) (int, error)

HTML Override any context's method you want... [...]

func (*Context) Next Uses

func (c *Context) Next()

Next The second one important if you will override the Context with an embedded context.Context inside it. Required in order to run the chain of handlers via this "*Context".

func (*Context) ResponseBody Uses

func (c *Context) ResponseBody(message string, data interface{})

ResponseBody set response

func (*Context) ResponseError Uses

func (c *Context) ResponseError(message string, code int)

ResponseError response with error

func (*Context) ResponseString Uses

func (c *Context) ResponseString(data string)

ResponseString set response

func (*Context) Translate Uses

func (c *Context) Translate(format string, args ...interface{}) string

Translate override base context method Translate to return format if i18n is not enabled

func (*Context) WrapHandler Uses

func (c *Context) WrapHandler(h http.Handler)

WrapHandler is a helper function for wrapping http.Handler

type Controller Uses

type Controller struct {
    at.RestController
}

Controller is the web base controller please use at.RestController instead

type Dispatcher Uses

type Dispatcher struct {
    SystemApp    *system.App
    SystemServer *system.Server

    ContextPathFormat string `value:"${server.context_path_format}" `
    // contains filtered or unexported fields
}

type HttpMethodSubscriber Uses

type HttpMethodSubscriber interface {
    Subscribe(atController *annotation.Annotations, atMethod *annotation.Annotations)
}

HttpMethodSubscriber

type TestApplication Uses

type TestApplication interface {
    Initialize() error
    SetProperty(name string, value ...interface{}) TestApplication
    Run(t *testing.T) TestApplication
    Request(method, path string, pathargs ...interface{}) *httpexpect.Request
    Post(path string, pathargs ...interface{}) *httpexpect.Request
    Get(path string, pathargs ...interface{}) *httpexpect.Request
    Put(path string, pathargs ...interface{}) *httpexpect.Request
    Delete(path string, pathargs ...interface{}) *httpexpect.Request
    Patch(path string, pathargs ...interface{}) *httpexpect.Request
    Options(path string, pathargs ...interface{}) *httpexpect.Request
}

TestApplication the test web application interface for unit test only

func NewTestApp Uses

func NewTestApp(controllers ...interface{}) TestApplication

NewTestApp returns the new test application

func RunTestApplication Uses

func RunTestApplication(t *testing.T, controllers ...interface{}) TestApplication

RunTestApplication returns the new test application

Directories

PathSynopsis
context

Package web imports 34 packages (graph) and is imported by 4 packages. Updated 2019-10-16. Refresh now. Tools for package owners.