README

Sourcegraph GoDoc Go Report Card Build Status Codecov Forum Twitter License

Feature Overview

  • Optimized HTTP router which smartly prioritize routes
  • Build robust and scalable RESTful APIs
  • Group APIs
  • Extensible middleware framework
  • Define middleware at root, group or route level
  • Data binding for JSON, XML and form payload
  • Handy functions to send variety of HTTP responses
  • Centralized HTTP error handling
  • Template rendering with any template engine
  • Define your format for the logger
  • Highly customizable
  • Automatic TLS via Let’s Encrypt
  • HTTP/2 support

Benchmarks

Date: 2018/03/15
Source: https://github.com/vishr/web-framework-benchmark
Lower is better!

Guide

Example

package main

import (
	"net/http"

	"github.com/labstack/echo"
	"github.com/labstack/echo/middleware"
)

func main() {
	// Echo instance
	e := echo.New()

	// Middleware
	e.Use(middleware.Logger())
	e.Use(middleware.Recover())

	// Routes
	e.GET("/", hello)

	// Start server
	e.Logger.Fatal(e.Start(":1323"))
}

// Handler
func hello(c echo.Context) error {
	return c.String(http.StatusOK, "Hello, World!")
}

Help

Contribute

Use issues for everything

  • For a small change, just send a PR.
  • For bigger changes open an issue for discussion before sending a PR.
  • PR should have:
    • Test case
    • Documentation
    • Example (If it makes sense)
  • You can also contribute by:
    • Reporting issues
    • Suggesting new features or enhancements
    • Improve/fix documentation

Credits

License

MIT

Expand ▾ Collapse ▴

Documentation

Overview

    Package echo implements high performance, minimalist Go web framework.

    Example:

    package main
    
    import (
      "net/http"
    
      "github.com/labstack/echo"
      "github.com/labstack/echo/middleware"
    )
    
    // Handler
    func hello(c echo.Context) error {
      return c.String(http.StatusOK, "Hello, World!")
    }
    
    func main() {
      // Echo instance
      e := echo.New()
    
      // Middleware
      e.Use(middleware.Logger())
      e.Use(middleware.Recover())
    
      // Routes
      e.GET("/", hello)
    
      // Start server
      e.Logger.Fatal(e.Start(":1323"))
    }
    

    Learn more at https://echo.labstack.com

    Index

    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
    	// PROPFIND = "PROPFIND"
    	PUT   = http.MethodPut
    	TRACE = http.MethodTrace
    )

      HTTP methods NOTE: Deprecated, please use the stdlib constants directly instead.

      View Source
      const (
      	MIMEApplicationJSON                  = "application/json"
      	MIMEApplicationJSONCharsetUTF8       = MIMEApplicationJSON + "; " + charsetUTF8
      	MIMEApplicationJavaScript            = "application/javascript"
      	MIMEApplicationJavaScriptCharsetUTF8 = MIMEApplicationJavaScript + "; " + charsetUTF8
      	MIMEApplicationXML                   = "application/xml"
      	MIMEApplicationXMLCharsetUTF8        = MIMEApplicationXML + "; " + charsetUTF8
      	MIMETextXML                          = "text/xml"
      	MIMETextXMLCharsetUTF8               = MIMETextXML + "; " + charsetUTF8
      	MIMEApplicationForm                  = "application/x-www-form-urlencoded"
      	MIMEApplicationProtobuf              = "application/protobuf"
      	MIMEApplicationMsgpack               = "application/msgpack"
      	MIMETextHTML                         = "text/html"
      	MIMETextHTMLCharsetUTF8              = MIMETextHTML + "; " + charsetUTF8
      	MIMETextPlain                        = "text/plain"
      	MIMETextPlainCharsetUTF8             = MIMETextPlain + "; " + charsetUTF8
      	MIMEMultipartForm                    = "multipart/form-data"
      	MIMEOctetStream                      = "application/octet-stream"
      )

        MIME types

        View Source
        const (
        	HeaderAccept              = "Accept"
        	HeaderAcceptEncoding      = "Accept-Encoding"
        	HeaderAllow               = "Allow"
        	HeaderAuthorization       = "Authorization"
        	HeaderContentDisposition  = "Content-Disposition"
        	HeaderContentEncoding     = "Content-Encoding"
        	HeaderContentLength       = "Content-Length"
        	HeaderContentType         = "Content-Type"
        	HeaderCookie              = "Cookie"
        	HeaderSetCookie           = "Set-Cookie"
        	HeaderIfModifiedSince     = "If-Modified-Since"
        	HeaderLastModified        = "Last-Modified"
        	HeaderLocation            = "Location"
        	HeaderUpgrade             = "Upgrade"
        	HeaderVary                = "Vary"
        	HeaderWWWAuthenticate     = "WWW-Authenticate"
        	HeaderXForwardedFor       = "X-Forwarded-For"
        	HeaderXForwardedProto     = "X-Forwarded-Proto"
        	HeaderXForwardedProtocol  = "X-Forwarded-Protocol"
        	HeaderXForwardedSsl       = "X-Forwarded-Ssl"
        	HeaderXUrlScheme          = "X-Url-Scheme"
        	HeaderXHTTPMethodOverride = "X-HTTP-Method-Override"
        	HeaderXRealIP             = "X-Real-IP"
        	HeaderXRequestID          = "X-Request-ID"
        	HeaderXRequestedWith      = "X-Requested-With"
        	HeaderServer              = "Server"
        	HeaderOrigin              = "Origin"
        
        	// Access control
        	HeaderAccessControlRequestMethod    = "Access-Control-Request-Method"
        	HeaderAccessControlRequestHeaders   = "Access-Control-Request-Headers"
        	HeaderAccessControlAllowOrigin      = "Access-Control-Allow-Origin"
        	HeaderAccessControlAllowMethods     = "Access-Control-Allow-Methods"
        	HeaderAccessControlAllowHeaders     = "Access-Control-Allow-Headers"
        	HeaderAccessControlAllowCredentials = "Access-Control-Allow-Credentials"
        	HeaderAccessControlExposeHeaders    = "Access-Control-Expose-Headers"
        	HeaderAccessControlMaxAge           = "Access-Control-Max-Age"
        
        	// Security
        	HeaderStrictTransportSecurity = "Strict-Transport-Security"
        	HeaderXContentTypeOptions     = "X-Content-Type-Options"
        	HeaderXXSSProtection          = "X-XSS-Protection"
        	HeaderXFrameOptions           = "X-Frame-Options"
        	HeaderContentSecurityPolicy   = "Content-Security-Policy"
        	HeaderXCSRFToken              = "X-CSRF-Token"
        )

          Headers

          View Source
          const (
          
          	// PROPFIND Method can be used on collection and property resources.
          	PROPFIND = "PROPFIND"
          )
          View Source
          const (
          	// Version of Echo
          	Version = "3.3.10-dev"
          )

          Variables

          View Source
          var (
          	ErrUnsupportedMediaType        = NewHTTPError(http.StatusUnsupportedMediaType)
          	ErrNotFound                    = NewHTTPError(http.StatusNotFound)
          	ErrUnauthorized                = NewHTTPError(http.StatusUnauthorized)
          	ErrForbidden                   = NewHTTPError(http.StatusForbidden)
          	ErrMethodNotAllowed            = NewHTTPError(http.StatusMethodNotAllowed)
          	ErrStatusRequestEntityTooLarge = NewHTTPError(http.StatusRequestEntityTooLarge)
          	ErrTooManyRequests             = NewHTTPError(http.StatusTooManyRequests)
          	ErrBadRequest                  = NewHTTPError(http.StatusBadRequest)
          	ErrBadGateway                  = NewHTTPError(http.StatusBadGateway)
          	ErrInternalServerError         = NewHTTPError(http.StatusInternalServerError)
          	ErrRequestTimeout              = NewHTTPError(http.StatusRequestTimeout)
          	ErrServiceUnavailable          = NewHTTPError(http.StatusServiceUnavailable)
          	ErrValidatorNotRegistered      = errors.New("validator not registered")
          	ErrRendererNotRegistered       = errors.New("renderer not registered")
          	ErrInvalidRedirectCode         = errors.New("invalid redirect status code")
          	ErrCookieNotFound              = errors.New("cookie not found")
          )

            Errors

            View Source
            var (
            	NotFoundHandler = func(c Context) error {
            		return ErrNotFound
            	}
            
            	MethodNotAllowedHandler = func(c Context) error {
            		return ErrMethodNotAllowed
            	}
            )

              Error handlers

              Functions

              This section is empty.

              Types

              type BindUnmarshaler

              type BindUnmarshaler interface {
              	// UnmarshalParam decodes and assigns a value from an form or query param.
              	UnmarshalParam(param string) error
              }

                BindUnmarshaler is the interface used to wrap the UnmarshalParam method.

                type Binder

                type Binder interface {
                	Bind(i interface{}, c Context) error
                }

                  Binder is the interface that wraps the Bind method.

                  type Context

                  type Context interface {
                  	// Request returns `*http.Request`.
                  	Request() *http.Request
                  
                  	// SetRequest sets `*http.Request`.
                  	SetRequest(r *http.Request)
                  
                  	// Response returns `*Response`.
                  	Response() *Response
                  
                  	// IsTLS returns true if HTTP connection is TLS otherwise false.
                  	IsTLS() bool
                  
                  	// IsWebSocket returns true if HTTP connection is WebSocket otherwise false.
                  	IsWebSocket() bool
                  
                  	// Scheme returns the HTTP protocol scheme, `http` or `https`.
                  	Scheme() string
                  
                  	// RealIP returns the client's network address based on `X-Forwarded-For`
                  	// or `X-Real-IP` request header.
                  	RealIP() string
                  
                  	// Path returns the registered path for the handler.
                  	Path() string
                  
                  	// SetPath sets the registered path for the handler.
                  	SetPath(p string)
                  
                  	// Param returns path parameter by name.
                  	Param(name string) string
                  
                  	// ParamNames returns path parameter names.
                  	ParamNames() []string
                  
                  	// SetParamNames sets path parameter names.
                  	SetParamNames(names ...string)
                  
                  	// ParamValues returns path parameter values.
                  	ParamValues() []string
                  
                  	// SetParamValues sets path parameter values.
                  	SetParamValues(values ...string)
                  
                  	// QueryParam returns the query param for the provided name.
                  	QueryParam(name string) string
                  
                  	// QueryParams returns the query parameters as `url.Values`.
                  	QueryParams() url.Values
                  
                  	// QueryString returns the URL query string.
                  	QueryString() string
                  
                  	// FormValue returns the form field value for the provided name.
                  	FormValue(name string) string
                  
                  	// FormParams returns the form parameters as `url.Values`.
                  	FormParams() (url.Values, error)
                  
                  	// FormFile returns the multipart form file for the provided name.
                  	FormFile(name string) (*multipart.FileHeader, error)
                  
                  	// MultipartForm returns the multipart form.
                  	MultipartForm() (*multipart.Form, error)
                  
                  	// Cookie returns the named cookie provided in the request.
                  	Cookie(name string) (*http.Cookie, error)
                  
                  	// SetCookie adds a `Set-Cookie` header in HTTP response.
                  	SetCookie(cookie *http.Cookie)
                  
                  	// Cookies returns the HTTP cookies sent with the request.
                  	Cookies() []*http.Cookie
                  
                  	// Get retrieves data from the context.
                  	Get(key string) interface{}
                  
                  	// Set saves data in the context.
                  	Set(key string, val interface{})
                  
                  	// Bind binds the request body into provided type `i`. The default binder
                  	// does it based on Content-Type header.
                  	Bind(i interface{}) error
                  
                  	// Validate validates provided `i`. It is usually called after `Context#Bind()`.
                  	// Validator must be registered using `Echo#Validator`.
                  	Validate(i interface{}) error
                  
                  	// Render renders a template with data and sends a text/html response with status
                  	// code. Renderer must be registered using `Echo.Renderer`.
                  	Render(code int, name string, data interface{}) error
                  
                  	// HTML sends an HTTP response with status code.
                  	HTML(code int, html string) error
                  
                  	// HTMLBlob sends an HTTP blob response with status code.
                  	HTMLBlob(code int, b []byte) error
                  
                  	// String sends a string response with status code.
                  	String(code int, s string) error
                  
                  	// JSON sends a JSON response with status code.
                  	JSON(code int, i interface{}) error
                  
                  	// JSONPretty sends a pretty-print JSON with status code.
                  	JSONPretty(code int, i interface{}, indent string) error
                  
                  	// JSONBlob sends a JSON blob response with status code.
                  	JSONBlob(code int, b []byte) error
                  
                  	// JSONP sends a JSONP response with status code. It uses `callback` to construct
                  	// the JSONP payload.
                  	JSONP(code int, callback string, i interface{}) error
                  
                  	// JSONPBlob sends a JSONP blob response with status code. It uses `callback`
                  	// to construct the JSONP payload.
                  	JSONPBlob(code int, callback string, b []byte) error
                  
                  	// XML sends an XML response with status code.
                  	XML(code int, i interface{}) error
                  
                  	// XMLPretty sends a pretty-print XML with status code.
                  	XMLPretty(code int, i interface{}, indent string) error
                  
                  	// XMLBlob sends an XML blob response with status code.
                  	XMLBlob(code int, b []byte) error
                  
                  	// Blob sends a blob response with status code and content type.
                  	Blob(code int, contentType string, b []byte) error
                  
                  	// Stream sends a streaming response with status code and content type.
                  	Stream(code int, contentType string, r io.Reader) error
                  
                  	// File sends a response with the content of the file.
                  	File(file string) error
                  
                  	// Attachment sends a response as attachment, prompting client to save the
                  	// file.
                  	Attachment(file string, name string) error
                  
                  	// Inline sends a response as inline, opening the file in the browser.
                  	Inline(file string, name string) error
                  
                  	// NoContent sends a response with no body and a status code.
                  	NoContent(code int) error
                  
                  	// Redirect redirects the request to a provided URL with status code.
                  	Redirect(code int, url string) error
                  
                  	// Error invokes the registered HTTP error handler. Generally used by middleware.
                  	Error(err error)
                  
                  	// Handler returns the matched handler by router.
                  	Handler() HandlerFunc
                  
                  	// SetHandler sets the matched handler by router.
                  	SetHandler(h HandlerFunc)
                  
                  	// Logger returns the `Logger` instance.
                  	Logger() Logger
                  
                  	// Echo returns the `Echo` instance.
                  	Echo() *Echo
                  
                  	// Reset resets the context after request completes. It must be called along
                  	// with `Echo#AcquireContext()` and `Echo#ReleaseContext()`.
                  	// See `Echo#ServeHTTP()`
                  	Reset(r *http.Request, w http.ResponseWriter)
                  }

                    Context represents the context of the current HTTP request. It holds request and response objects, path, path parameters, data and registered handler.

                    type DefaultBinder

                    type DefaultBinder struct{}

                      DefaultBinder is the default implementation of the Binder interface.

                      func (*DefaultBinder) Bind

                      func (b *DefaultBinder) Bind(i interface{}, c Context) (err error)

                        Bind implements the `Binder#Bind` function.

                        type Echo

                        type Echo struct {
                        	StdLogger *stdLog.Logger
                        
                        	Server           *http.Server
                        	TLSServer        *http.Server
                        	Listener         net.Listener
                        	TLSListener      net.Listener
                        	AutoTLSManager   autocert.Manager
                        	DisableHTTP2     bool
                        	Debug            bool
                        	HideBanner       bool
                        	HidePort         bool
                        	HTTPErrorHandler HTTPErrorHandler
                        	Binder           Binder
                        	Validator        Validator
                        	Renderer         Renderer
                        	Logger           Logger
                        	// contains filtered or unexported fields
                        }

                          Echo is the top-level framework instance.

                          func New

                          func New() (e *Echo)

                            New creates an instance of Echo.

                            func (*Echo) AcquireContext

                            func (e *Echo) AcquireContext() Context

                              AcquireContext returns an empty `Context` instance from the pool. You must return the context by calling `ReleaseContext()`.

                              func (*Echo) Add

                              func (e *Echo) Add(method, path string, handler HandlerFunc, middleware ...MiddlewareFunc) *Route

                                Add registers a new route for an HTTP method and path with matching handler in the router with optional route-level middleware.

                                func (*Echo) Any

                                func (e *Echo) Any(path string, handler HandlerFunc, middleware ...MiddlewareFunc) []*Route

                                  Any registers a new route for all HTTP methods and path with matching handler in the router with optional route-level middleware.

                                  func (*Echo) CONNECT

                                  func (e *Echo) CONNECT(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                    CONNECT registers a new CONNECT route for a path with matching handler in the router with optional route-level middleware.

                                    func (*Echo) Close

                                    func (e *Echo) Close() error

                                      Close immediately stops the server. It internally calls `http.Server#Close()`.

                                      func (*Echo) DELETE

                                      func (e *Echo) DELETE(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                        DELETE registers a new DELETE route for a path with matching handler in the router with optional route-level middleware.

                                        func (*Echo) DefaultHTTPErrorHandler

                                        func (e *Echo) DefaultHTTPErrorHandler(err error, c Context)

                                          DefaultHTTPErrorHandler is the default HTTP error handler. It sends a JSON response with status code.

                                          func (*Echo) File

                                          func (e *Echo) File(path, file string, m ...MiddlewareFunc) *Route

                                            File registers a new route with path to serve a static file with optional route-level middleware.

                                            func (*Echo) GET

                                            func (e *Echo) GET(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                              GET registers a new GET route for a path with matching handler in the router with optional route-level middleware.

                                              func (*Echo) Group

                                              func (e *Echo) Group(prefix string, m ...MiddlewareFunc) (g *Group)

                                                Group creates a new router group with prefix and optional group-level middleware.

                                                func (*Echo) HEAD

                                                func (e *Echo) HEAD(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                  HEAD registers a new HEAD route for a path with matching handler in the router with optional route-level middleware.

                                                  func (*Echo) Match

                                                  func (e *Echo) Match(methods []string, path string, handler HandlerFunc, middleware ...MiddlewareFunc) []*Route

                                                    Match registers a new route for multiple HTTP methods and path with matching handler in the router with optional route-level middleware.

                                                    func (*Echo) NewContext

                                                    func (e *Echo) NewContext(r *http.Request, w http.ResponseWriter) Context

                                                      NewContext returns a Context instance.

                                                      func (*Echo) OPTIONS

                                                      func (e *Echo) OPTIONS(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                        OPTIONS registers a new OPTIONS route for a path with matching handler in the router with optional route-level middleware.

                                                        func (*Echo) PATCH

                                                        func (e *Echo) PATCH(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                          PATCH registers a new PATCH route for a path with matching handler in the router with optional route-level middleware.

                                                          func (*Echo) POST

                                                          func (e *Echo) POST(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                            POST registers a new POST route for a path with matching handler in the router with optional route-level middleware.

                                                            func (*Echo) PUT

                                                            func (e *Echo) PUT(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                              PUT registers a new PUT route for a path with matching handler in the router with optional route-level middleware.

                                                              func (*Echo) Pre

                                                              func (e *Echo) Pre(middleware ...MiddlewareFunc)

                                                                Pre adds middleware to the chain which is run before router.

                                                                func (*Echo) ReleaseContext

                                                                func (e *Echo) ReleaseContext(c Context)

                                                                  ReleaseContext returns the `Context` instance back to the pool. You must call it after `AcquireContext()`.

                                                                  func (*Echo) Reverse

                                                                  func (e *Echo) Reverse(name string, params ...interface{}) string

                                                                    Reverse generates an URL from route name and provided parameters.

                                                                    func (*Echo) Router

                                                                    func (e *Echo) Router() *Router

                                                                      Router returns router.

                                                                      func (*Echo) Routes

                                                                      func (e *Echo) Routes() []*Route

                                                                        Routes returns the registered routes.

                                                                        func (*Echo) ServeHTTP

                                                                        func (e *Echo) ServeHTTP(w http.ResponseWriter, r *http.Request)

                                                                          ServeHTTP implements `http.Handler` interface, which serves HTTP requests.

                                                                          func (*Echo) Shutdown

                                                                          func (e *Echo) Shutdown(ctx stdContext.Context) error

                                                                            Shutdown stops the server gracefully. It internally calls `http.Server#Shutdown()`.

                                                                            func (*Echo) Start

                                                                            func (e *Echo) Start(address string) error

                                                                              Start starts an HTTP server.

                                                                              func (*Echo) StartAutoTLS

                                                                              func (e *Echo) StartAutoTLS(address string) error

                                                                                StartAutoTLS starts an HTTPS server using certificates automatically installed from https://letsencrypt.org.

                                                                                func (*Echo) StartServer

                                                                                func (e *Echo) StartServer(s *http.Server) (err error)

                                                                                  StartServer starts a custom http server.

                                                                                  func (*Echo) StartTLS

                                                                                  func (e *Echo) StartTLS(address string, certFile, keyFile string) (err error)

                                                                                    StartTLS starts an HTTPS server.

                                                                                    func (*Echo) Static

                                                                                    func (e *Echo) Static(prefix, root string) *Route

                                                                                      Static registers a new route with path prefix to serve static files from the provided root directory.

                                                                                      func (*Echo) TRACE

                                                                                      func (e *Echo) TRACE(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                                                        TRACE registers a new TRACE route for a path with matching handler in the router with optional route-level middleware.

                                                                                        func (*Echo) URI

                                                                                        func (e *Echo) URI(handler HandlerFunc, params ...interface{}) string

                                                                                          URI generates a URI from handler.

                                                                                          func (*Echo) URL

                                                                                          func (e *Echo) URL(h HandlerFunc, params ...interface{}) string

                                                                                            URL is an alias for `URI` function.

                                                                                            func (*Echo) Use

                                                                                            func (e *Echo) Use(middleware ...MiddlewareFunc)

                                                                                              Use adds middleware to the chain which is run after router.

                                                                                              type Group

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

                                                                                                Group is a set of sub-routes for a specified route. It can be used for inner routes that share a common middleware or functionality that should be separate from the parent echo instance while still inheriting from it.

                                                                                                func (*Group) Add

                                                                                                func (g *Group) Add(method, path string, handler HandlerFunc, middleware ...MiddlewareFunc) *Route

                                                                                                  Add implements `Echo#Add()` for sub-routes within the Group.

                                                                                                  func (*Group) Any

                                                                                                  func (g *Group) Any(path string, handler HandlerFunc, middleware ...MiddlewareFunc) []*Route

                                                                                                    Any implements `Echo#Any()` for sub-routes within the Group.

                                                                                                    func (*Group) CONNECT

                                                                                                    func (g *Group) CONNECT(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                                                                      CONNECT implements `Echo#CONNECT()` for sub-routes within the Group.

                                                                                                      func (*Group) DELETE

                                                                                                      func (g *Group) DELETE(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                                                                        DELETE implements `Echo#DELETE()` for sub-routes within the Group.

                                                                                                        func (*Group) File

                                                                                                        func (g *Group) File(path, file string)

                                                                                                          File implements `Echo#File()` for sub-routes within the Group.

                                                                                                          func (*Group) GET

                                                                                                          func (g *Group) GET(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                                                                            GET implements `Echo#GET()` for sub-routes within the Group.

                                                                                                            func (*Group) Group

                                                                                                            func (g *Group) Group(prefix string, middleware ...MiddlewareFunc) *Group

                                                                                                              Group creates a new sub-group with prefix and optional sub-group-level middleware.

                                                                                                              func (*Group) HEAD

                                                                                                              func (g *Group) HEAD(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                                                                                HEAD implements `Echo#HEAD()` for sub-routes within the Group.

                                                                                                                func (*Group) Match

                                                                                                                func (g *Group) Match(methods []string, path string, handler HandlerFunc, middleware ...MiddlewareFunc) []*Route

                                                                                                                  Match implements `Echo#Match()` for sub-routes within the Group.

                                                                                                                  func (*Group) OPTIONS

                                                                                                                  func (g *Group) OPTIONS(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                                                                                    OPTIONS implements `Echo#OPTIONS()` for sub-routes within the Group.

                                                                                                                    func (*Group) PATCH

                                                                                                                    func (g *Group) PATCH(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                                                                                      PATCH implements `Echo#PATCH()` for sub-routes within the Group.

                                                                                                                      func (*Group) POST

                                                                                                                      func (g *Group) POST(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                                                                                        POST implements `Echo#POST()` for sub-routes within the Group.

                                                                                                                        func (*Group) PUT

                                                                                                                        func (g *Group) PUT(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                                                                                          PUT implements `Echo#PUT()` for sub-routes within the Group.

                                                                                                                          func (*Group) Static

                                                                                                                          func (g *Group) Static(prefix, root string)

                                                                                                                            Static implements `Echo#Static()` for sub-routes within the Group.

                                                                                                                            func (*Group) TRACE

                                                                                                                            func (g *Group) TRACE(path string, h HandlerFunc, m ...MiddlewareFunc) *Route

                                                                                                                              TRACE implements `Echo#TRACE()` for sub-routes within the Group.

                                                                                                                              func (*Group) Use

                                                                                                                              func (g *Group) Use(middleware ...MiddlewareFunc)

                                                                                                                                Use implements `Echo#Use()` for sub-routes within the Group.

                                                                                                                                type HTTPError

                                                                                                                                type HTTPError struct {
                                                                                                                                	Code     int
                                                                                                                                	Message  interface{}
                                                                                                                                	Internal error // Stores the error returned by an external dependency
                                                                                                                                }

                                                                                                                                  HTTPError represents an error that occurred while handling a request.

                                                                                                                                  func NewHTTPError

                                                                                                                                  func NewHTTPError(code int, message ...interface{}) *HTTPError

                                                                                                                                    NewHTTPError creates a new HTTPError instance.

                                                                                                                                    func (*HTTPError) Error

                                                                                                                                    func (he *HTTPError) Error() string

                                                                                                                                      Error makes it compatible with `error` interface.

                                                                                                                                      func (*HTTPError) SetInternal

                                                                                                                                      func (he *HTTPError) SetInternal(err error) *HTTPError

                                                                                                                                        SetInternal sets error to HTTPError.Internal

                                                                                                                                        type HTTPErrorHandler

                                                                                                                                        type HTTPErrorHandler func(error, Context)

                                                                                                                                          HTTPErrorHandler is a centralized HTTP error handler.

                                                                                                                                          type HandlerFunc

                                                                                                                                          type HandlerFunc func(Context) error

                                                                                                                                            HandlerFunc defines a function to serve HTTP requests.

                                                                                                                                            func WrapHandler

                                                                                                                                            func WrapHandler(h http.Handler) HandlerFunc

                                                                                                                                              WrapHandler wraps `http.Handler` into `echo.HandlerFunc`.

                                                                                                                                              type Logger

                                                                                                                                              type Logger interface {
                                                                                                                                              	Output() io.Writer
                                                                                                                                              	SetOutput(w io.Writer)
                                                                                                                                              	Prefix() string
                                                                                                                                              	SetPrefix(p string)
                                                                                                                                              	Level() log.Lvl
                                                                                                                                              	SetLevel(v log.Lvl)
                                                                                                                                              	SetHeader(h string)
                                                                                                                                              	Print(i ...interface{})
                                                                                                                                              	Printf(format string, args ...interface{})
                                                                                                                                              	Printj(j log.JSON)
                                                                                                                                              	Debug(i ...interface{})
                                                                                                                                              	Debugf(format string, args ...interface{})
                                                                                                                                              	Debugj(j log.JSON)
                                                                                                                                              	Info(i ...interface{})
                                                                                                                                              	Infof(format string, args ...interface{})
                                                                                                                                              	Infoj(j log.JSON)
                                                                                                                                              	Warn(i ...interface{})
                                                                                                                                              	Warnf(format string, args ...interface{})
                                                                                                                                              	Warnj(j log.JSON)
                                                                                                                                              	Error(i ...interface{})
                                                                                                                                              	Errorf(format string, args ...interface{})
                                                                                                                                              	Errorj(j log.JSON)
                                                                                                                                              	Fatal(i ...interface{})
                                                                                                                                              	Fatalj(j log.JSON)
                                                                                                                                              	Fatalf(format string, args ...interface{})
                                                                                                                                              	Panic(i ...interface{})
                                                                                                                                              	Panicj(j log.JSON)
                                                                                                                                              	Panicf(format string, args ...interface{})
                                                                                                                                              }

                                                                                                                                                Logger defines the logging interface.

                                                                                                                                                type Map

                                                                                                                                                type Map map[string]interface{}

                                                                                                                                                  Map defines a generic map of type `map[string]interface{}`.

                                                                                                                                                  type MiddlewareFunc

                                                                                                                                                  type MiddlewareFunc func(HandlerFunc) HandlerFunc

                                                                                                                                                    MiddlewareFunc defines a function to process middleware.

                                                                                                                                                    func WrapMiddleware

                                                                                                                                                    func WrapMiddleware(m func(http.Handler) http.Handler) MiddlewareFunc

                                                                                                                                                      WrapMiddleware wraps `func(http.Handler) http.Handler` into `echo.MiddlewareFunc`

                                                                                                                                                      type Renderer

                                                                                                                                                      type Renderer interface {
                                                                                                                                                      	Render(io.Writer, string, interface{}, Context) error
                                                                                                                                                      }

                                                                                                                                                        Renderer is the interface that wraps the Render function.

                                                                                                                                                        type Response

                                                                                                                                                        type Response struct {
                                                                                                                                                        	Writer    http.ResponseWriter
                                                                                                                                                        	Status    int
                                                                                                                                                        	Size      int64
                                                                                                                                                        	Committed bool
                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                        }

                                                                                                                                                          Response wraps an http.ResponseWriter and implements its interface to be used by an HTTP handler to construct an HTTP response. See: https://golang.org/pkg/net/http/#ResponseWriter

                                                                                                                                                          func NewResponse

                                                                                                                                                          func NewResponse(w http.ResponseWriter, e *Echo) (r *Response)

                                                                                                                                                            NewResponse creates a new instance of Response.

                                                                                                                                                            func (*Response) After

                                                                                                                                                            func (r *Response) After(fn func())

                                                                                                                                                              After registers a function which is called just after the response is written. If the `Content-Length` is unknown, none of the after function is executed.

                                                                                                                                                              func (*Response) Before

                                                                                                                                                              func (r *Response) Before(fn func())

                                                                                                                                                                Before registers a function which is called just before the response is written.

                                                                                                                                                                func (*Response) CloseNotify

                                                                                                                                                                func (r *Response) CloseNotify() <-chan bool

                                                                                                                                                                  CloseNotify implements the http.CloseNotifier interface to allow detecting when the underlying connection has gone away. This mechanism can be used to cancel long operations on the server if the client has disconnected before the response is ready. See [http.CloseNotifier](https://golang.org/pkg/net/http/#CloseNotifier)

                                                                                                                                                                  func (*Response) Flush

                                                                                                                                                                  func (r *Response) Flush()

                                                                                                                                                                    Flush implements the http.Flusher interface to allow an HTTP handler to flush buffered data to the client. See [http.Flusher](https://golang.org/pkg/net/http/#Flusher)

                                                                                                                                                                    func (*Response) Header

                                                                                                                                                                    func (r *Response) Header() http.Header

                                                                                                                                                                      Header returns the header map for the writer that will be sent by WriteHeader. Changing the header after a call to WriteHeader (or Write) has no effect unless the modified headers were declared as trailers by setting the "Trailer" header before the call to WriteHeader (see example) To suppress implicit response headers, set their value to nil. Example: https://golang.org/pkg/net/http/#example_ResponseWriter_trailers

                                                                                                                                                                      func (*Response) Hijack

                                                                                                                                                                      func (r *Response) Hijack() (net.Conn, *bufio.ReadWriter, error)

                                                                                                                                                                        Hijack implements the http.Hijacker interface to allow an HTTP handler to take over the connection. See [http.Hijacker](https://golang.org/pkg/net/http/#Hijacker)

                                                                                                                                                                        func (*Response) Write

                                                                                                                                                                        func (r *Response) Write(b []byte) (n int, err error)

                                                                                                                                                                          Write writes the data to the connection as part of an HTTP reply.

                                                                                                                                                                          func (*Response) WriteHeader

                                                                                                                                                                          func (r *Response) WriteHeader(code int)

                                                                                                                                                                            WriteHeader sends an HTTP response header with status code. If WriteHeader is not called explicitly, the first call to Write will trigger an implicit WriteHeader(http.StatusOK). Thus explicit calls to WriteHeader are mainly used to send error codes.

                                                                                                                                                                            type Route

                                                                                                                                                                            type Route struct {
                                                                                                                                                                            	Method string `json:"method"`
                                                                                                                                                                            	Path   string `json:"path"`
                                                                                                                                                                            	Name   string `json:"name"`
                                                                                                                                                                            }

                                                                                                                                                                              Route contains a handler and information for matching against requests.

                                                                                                                                                                              type Router

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

                                                                                                                                                                                Router is the registry of all registered routes for an `Echo` instance for request matching and URL path parameter parsing.

                                                                                                                                                                                func NewRouter

                                                                                                                                                                                func NewRouter(e *Echo) *Router

                                                                                                                                                                                  NewRouter returns a new Router instance.

                                                                                                                                                                                  func (*Router) Add

                                                                                                                                                                                  func (r *Router) Add(method, path string, h HandlerFunc)

                                                                                                                                                                                    Add registers a new route for method and path with matching handler.

                                                                                                                                                                                    func (*Router) Find

                                                                                                                                                                                    func (r *Router) Find(method, path string, c Context)

                                                                                                                                                                                      Find lookup a handler registered for method and path. It also parses URL for path parameters and load them into context.

                                                                                                                                                                                      For performance:

                                                                                                                                                                                      - Get context from `Echo#AcquireContext()` - Reset it `Context#Reset()` - Return it `Echo#ReleaseContext()`.

                                                                                                                                                                                      type Validator

                                                                                                                                                                                      type Validator interface {
                                                                                                                                                                                      	Validate(i interface{}) error
                                                                                                                                                                                      }

                                                                                                                                                                                        Validator is the interface that wraps the Validate function.

                                                                                                                                                                                        Directories

                                                                                                                                                                                        Path Synopsis