Download gear - Download do código -fonte gear

Uma estrutura de serviço da Web leve, composável e de alto desempenho para GO.

Características

Controle de fluxo de louros médios eficaz e flexível, crie qualquer coisa por middleware
Manuseio de erro HTTP poderoso e inteligente
Trie Base Gear.
Timeout integrado context.Context
Compressão de conteúdo de resposta integrada
Middleware de madeira estruturada integrada
Analisador corporal de solicitação integrado
Cookies assinados integrados
JSON, JSONP, XML e HTML Integrado
Cors integrados, seguros, favicon e middlewares estáticos
Métodos mais úteis no Gear.Context para manipular a solicitação/resposta HTTP
Execute HTTP e GRPC na mesma porta
Completamente HTTP/2.0 suportado

Documentação

Documentação para Go

Importar

 // package gear
import "github.com/teambition/gear"

Projeto

A camada subjacente do servidor é baseada na rede nativa/http em vez de fastthttp
Estender módulos de função através da engrenagem. Modo de middleware middleware
Controle de processo seqüencial unidirecional e controle do processo em cascata do middleware
Gear poderoso e perfeitamente integrado.Context com Context.Context
Erro centralizado, inteligente e personalizável e manuseio de exceção
Pós-processamento para o gancho após o gancho
Qualquer interface INLIMITED EGNES.CONTEXT ESTADO REPAÇÃO DE EXPANSIÇÃO
Policial de dados solicitado e verificação

Perguntas frequentes

Como gerar automaticamente documentos Swagger V2 a partir do código -fonte?
Quais são as práticas recomendadas para a estrutura completa do projeto do aplicativo do idioma Go?

Demonstração

Olá

https://github.com/teambition/gear/tree/master/example/hello

  app := gear . New ()

  // Add logging middleware
  app . UseHandler ( logging . Default ( true ))

  // Add router middleware
  router := gear . NewRouter ()

  // try: http://127.0.0.1:3000/hello
  router . Get ( "/hello" , func ( ctx * gear. Context ) error {
    return ctx . HTML ( 200 , "<h1>Hello, Gear!</h1>" )
  })

  // try: http://127.0.0.1:3000/test?query=hello
  router . Otherwise ( func ( ctx * gear. Context ) error {
    return ctx . JSON ( 200 , map [ string ] any {
      "Host" :    ctx . Host ,
      "Method" :  ctx . Method ,
      "Path" :    ctx . Path ,
      "URI" :     ctx . Req . RequestURI ,
      "Headers" : ctx . Req . Header ,
    })
  })
  app . UseHandler ( router )
  app . Error ( app . Listen ( ":3000" ))

Http2 com push

https://github.com/teambition/gear/tree/master/example/http2

 package main

import (
  "net/http"

  "github.com/teambition/gear"
  "github.com/teambition/gear/logging"
  "github.com/teambition/gear/middleware/favicon"
)

// go run example/http2/app.go
// Visit: https://127.0.0.1:3000/
func main () {
  const htmlBody = `
<!DOCTYPE html>
<html>
  <head>
    <link href="/hello.css" rel="stylesheet" type="text/css">
  </head>
  <body>
    <h1>Hello, Gear!</h1>
  </body>
</html>`

  const pushBody = `
h1 {
  color: red;
}
`

  app := gear . New ()

  app . UseHandler ( logging . Default ( true ))
  app . Use ( favicon . New ( "./testdata/favicon.ico" ))

  router := gear . NewRouter ()
  router . Get ( "/" , func ( ctx * gear. Context ) error {
    ctx . Res . Push ( "/hello.css" , & http. PushOptions { Method : "GET" })
    return ctx . HTML ( 200 , htmlBody )
  })
  router . Get ( "/hello.css" , func ( ctx * gear. Context ) error {
    ctx . Type ( "text/css" )
    return ctx . End ( 200 , [] byte ( pushBody ))
  })
  app . UseHandler ( router )
  app . Error ( app . ListenTLS ( ":3000" , "./testdata/out/test.crt" , "./testdata/out/test.key" ))
}

Uma ferramenta CMD: servidor estático

https://github.com/teambition/gear/tree/master/example/staticgo

Instale -o com Go:

go install github.com/teambition/gear/example/staticgo@latest

É uma ferramenta CMD útil que serve seus arquivos locais como servidor da Web (suportar TLS). Você pode criar a versão osx , linux , windows com make build .

 package main

import (
  "flag"

  "github.com/teambition/gear"
  "github.com/teambition/gear/logging"
  "github.com/teambition/gear/middleware/cors"
  "github.com/teambition/gear/middleware/static"
)

var (
  address  = flag . String ( "addr" , "127.0.0.1:3000" , `address to listen on.` )
  path     = flag . String ( "path" , "./" , `static files path to serve.` )
  certFile = flag . String ( "certFile" , "" , `certFile path, used to create TLS static server.` )
  keyFile  = flag . String ( "keyFile" , "" , `keyFile path, used to create TLS static server.` )
)

func main () {
  flag . Parse ()
  app := gear . New ()

  app . UseHandler ( logging . Default ( true ))
  app . Use ( cors . New ())
  app . Use ( static . New (static. Options { Root : * path }))

  logging . Println ( "staticgo v1.2.0, created by https://github.com/teambition/gear" )
  logging . Printf ( "listen: %s, serve: %s n " , * address , * path )

  if * certFile != "" && * keyFile != "" {
    app . Error ( app . ListenTLS ( * address , * certFile , * keyFile ))
  } else {
    app . Error ( app . Listen ( * address ))
  }
}

Uma ferramenta CMD: servidor proxy reverso

https://github.com/teambition/gear/tree/master/example/gearproxy

Instale -o com Go:

go install github.com/teambition/gear/example/gearproxy@latest
gearproxy -help

HTTP2 e GRPC

https://github.com/teambition/gear/tree/master/example/grpc_server

https://github.com/teambition/gear/tree/master/example/grpc_client

Sobre o roteador

Gear.Router é um manipulador de solicitação HTTP da Base Trie. Características:

Suporte denominado parâmetro
Suporte regexp
Suporte a correspondência de sufixo
Apoie o Multi-Router
Suporte Middlewares da camada de roteador
Suporte a redirecionamento automático do caminho fixo
Suporte ao arrasto de redirecionamento automático
Monta automático 405 Method Not Allowed
Método OPTIONS de manipulação automática
Melhor desempenho

O caminho registrado, contra o qual o roteador corresponde às solicitações recebidas, pode conter seis tipos de parâmetros:

Sintaxe	Descrição
`:name`	parâmetro nomeado
`:name(regexp)`	nomeado com parâmetro regexp
`:name+suffix`	parâmetro nomeado com correspondência de sufixo
`:name(regexp)+suffix`	nomeado com parâmetro regexp e correspondência de sufixo
`:name*`	nomeado com parâmetro de captura-all
`::name`	Não nomeado parâmetro, é literal `:name`

Os parâmetros nomeados são segmentos de caminho dinâmico. Eles combinam qualquer coisa até o próximo '/' ou o caminho final:

Definido: /api/:type/:ID

/api/user/123             matched: type="user", ID="123"
/api/user                 no match
/api/user/123/comments    no match

Nomeado com os parâmetros regexp correspondem a qualquer coisa usando o regexp até o próximo '/' ou o final do caminho:

Definido: /api/:type/:ID(^d+$)

/api/user/123             matched: type="user", ID="123"
/api/user                 no match
/api/user/abc             no match
/api/user/123/comments    no match

Parâmetros nomeados com sufixo, como o Google API Design:

Definido: /api/:resource/:ID+:undelete

/api/file/123                     no match
/api/file/123 : undelete            matched: resource="file", ID="123"
/api/file/123 : undelete /comments   no match

Nomeado com parâmetros e sufixo regexp:

Definido: /api/:resource/:ID(^d+$)+:cancel

/api/task/123                   no match
/api/task/123 : cancel            matched: resource="task", ID="123"
/api/task/abc : cancel            no match

Nomeado com os parâmetros de captura-todos, correspondam a qualquer coisa até o final do caminho, incluindo o índice de diretório (o '/' antes do Catch-All). Como eles correspondem a qualquer coisa até o final, os parâmetros de captura-todos devem sempre ser o elemento do caminho final.

Definido: /files/:filepath*

 /files                           no match
/files/LICENSE                   matched: filepath="LICENSE"
/files/templates/article.html    matched: filepath="templates/article.html"

O valor dos parâmetros é salvo no Matched.Params . Recupere o valor de um parâmetro por nome:

 type := matched . Params ( "type" )
id   := matched . Params ( "ID" )

Maiswares médios

Registro estruturado: github.com/teambition/gear/logging
Manipulador CORS: github.com/teambition/gear/middleware/cors
Manipulador seguro: github.com/teambition/gear/middleware/secure
Serviço estático: github.com/teambition/gear/middleware/static
Favicon Serviço: github.com/teambition/gear/middleware/favicon
GRPC SERVIÇÃO: github.com/teambition/gear/middleware/grpc
JWT e Crypto Auth: Gear-Auth
Sessão de biscoitos: engrenagem-sessão
Middleware da sessão: https://github.com/go-session/gear-session
Limitador de taxa inteligente: Ratelimitador de engrenagem
CSRF: Gear-CSRF
Opentação com Zipkin: rastreamento de engrenagem

Licença

Expandir

gear

Características

Documentação

Importar

Projeto

Perguntas frequentes

Demonstração

Olá

Http2 com push

Uma ferramenta CMD: servidor estático

Uma ferramenta CMD: servidor proxy reverso

HTTP2 e GRPC

Sobre o roteador

Maiswares médios

Licença

Pacote de instalação de equipamento de cura de engrenagens

A versão oficial chinesa do jogo Gear Clicker (Gear Clicker)

Baixar Future Strike Gear

Ascensão do Metal Gear: Re

Guilty Gear Xrd Re

Equipamento de filme GIF

chat.petals.dev

GPT Prompt Templates

GPTyped

Twitter Sentiment Analysis on Flask App

data science app road accident analysis

static web apps cli

Google Dorks

shepherd

mongo express