Dégustation du framework HTTP Go hautes performances

Qu’est-ce qu’Hertz ?

Hertz [həːts] est un haute performance, haute convivialité, extensible Cadre HTTP pour Go. Il est conçu pour simplifier la création de microservices pour les développeurs.

Pourquoi Hertz ?

L’un des points forts de Hertz est ses performances extrêmement élevées. Vous pouvez vous en faire une idée en consultant les statistiques suivantes sur les demandes d’écho.

Vous pouvez vous référer à hertz-benchmark pour plus d’informations.

Un autre point est sa facilité d’utilisation, dont nous parlerons ensuite.

Comment utiliser Hertz

Ici, nous allons écrire une démo simple pour vous aider à vous familiariser avec les fonctionnalités de base du framework Hertz.

Installation

Avant d’utiliser Hertz, vous devez configurer votre environnement de développement Golang et vous assurer qu’il est >= v1.15.

Une fois que notre environnement Golang est prêt, créons le dossier de projet de notre petite démo, qui est généralement sous $GOPATH/src.

mkdir userdemo
cd userdemo

Je recommande fortement d’utiliser l’outil de ligne de commande Hertz hz qui vient avec Hertz.

hz est un outil fourni par le framework Hertz pour générer du code. Actuellement, hz peut générer des échafaudages pour les projets Hertz basés sur l’épargne et l’IDL de protobuf.

Vous pouvez vous référer à l’utilisation de la boîte à outils hz pour plus d’informations.

go install github.com/cloudwego/hertz/cmd/hz@latest
hz -v

Si la hz les informations de version s’affichent correctement comme suit, nous avons terminé l’installation et sommes prêts avec l’environnement de développement Hertz de base.

Définir IDL

Dans cette section, nous allons écrire le fichier IDL pour notre projet userdemo.

hz peut utiliser thrift IDL ou protobuf IDL pour générer du code et doit installer le compilateur approprié thriftgo ou protoc. Nous utiliserons l’épargne comme exemple.

Créons un dossier idl et définissons user.thrift.

// idl/user.thrift

namespace go user



struct BaseResp {

    1: i64 StatusCode;

    2: string StatusMsg;

    3: string data;

}



struct RegisterRequest {

    1: string Username (api.body="username");

    2: string Password (api.body="password");

}



struct RegisterResponse {

    1: BaseResp BaseResp;

}



struct LoginRequest {

    1: string Username (api.body="username");

    2: string Password (api.body="password");

}



struct LoginResponse {

    1: BaseResp BaseResp;

}



struct InfoRequest {

    1: string Username (api.path="username");

}



struct InfoResponse {

    1: BaseResp BaseResp;

}



service UserService {

    RegisterResponse Register(1: RegisterRequest req) (api.post="/user/register");

    LoginResponse Login(1: LoginRequest req) (api.post="/user/login");

    InfoResponse Info(1: InfoRequest req) (api.get="/user/:username");

}

Générer du code

Exécutez la commande suivante sous le répertoire du projet. hz générera le code d’échafaudage pour nous.

hz new -idl idl/user.thrift
go mod tidy

Si vous modifiez user.thrift qui a généré du code, vous pouvez également mettre à jour le code généré à l’aide de la commande suivante.

hz update -idl idl/user.thrift

Voici la structure du code généré par le user.thrift et ce que cela signifie. Une simple compréhension de celui-ci vous aidera à démarrer.

.

├── biz                               // business layer, which stores business logic related processes

│   ├── handler                       // store handler file

│   │   ├── user                      // user corresponds to the namespace defined in thrift IDL; for protobuf IDL, it corresponds to the last level of go_package

│   │   │   |

│   │   │   |__  user_service.go      // the handler file, the user will implement the method defined by the IDL service in this file, it will search for the existing handler in the current file when "update" command, and append a new handler to the end

│   │   └── ping.go                   // ping handler carried by default, used to generate code for quick debugging, no other special meaning

│   ├── model                         // IDL content-related generation code

│   │   └── user                      // hello/example corresponds to the namespace defined in thrift IDL; for protobuf IDL, it corresponds to the last level of go_package 

│   │         └── user.go             // the product of thriftgo, It contains go code generated from the contents of hello.thrift definition. And it will be regenerated when use "update" command.

│   └── router                        // generated code related to the definition of routes in IDL

│       ├── user                      // hello/example corresponds to the namespace defined in thrift IDL; for protobuf IDL, it corresponds to the last level of go_package

│       │     ├── hello.go            // the route registration code generated for the routes defined in hello.thrift by hz; this file will be regenerated each time the relevant IDL is updated

│       │     └── middleware.go       // default middleware function, hz adds a middleware for each generated route group by default; when updating, it will look for the existing middleware in the current file and append new middleware at the end

│       └── register.go               // call and register the routing definition in each IDL file; when a new IDL is added, the call of its routing registration will be automatically inserted during the update; do not edit

├── go.mod                            // go.mod file, if not specified on the command line, defaults to a relative path to GOPATH as the module name

├── idl                               // user defined IDL, location can be arbitrary

│   └── user.thrift

├── main.go                           // program entry

├── router.go                         // user defined routing methods other than IDL

└── router_gen.go                     // the route registration code generated by hz, for calling user-defined routes and routes generated by hz

Utiliser le middleware

Hertz prend en charge un certain nombre de middleware couramment utilisés. Dans ce cas, nous utiliserons Intergiciel de session pour nous aider à compter le nombre de fois qu’un utilisateur s’est connecté.

Comme mentionné précédemment, hz nous a aidés à mettre en place de nombreux codes d’échafaudage. Nous n’avons qu’à nous concentrer sur le code des affaires. Pour utiliser le middleware Session, il vous suffit de modifier simplement le _loginMw méthode de middleware.go comme ci-dessous.

func _loginMw() []app.HandlerFunc {

   // your code...

   return []app.HandlerFunc{

      // use session middleware

      sessions.Sessions("usersession", cookie.NewStore([]byte("secret"))),

   }

}

Eh bien, n’est-ce pas facile?

Améliorer le gestionnaire

Ensuite, nous écrirons le gestionnaire, en particulier le user_service.go dossier.

Hertz s’occupe de la simple validation de la liaison de données et de certaines tâches. Il ne nous reste plus qu’à traiter la demande.

Regardons le Register méthode d’abord.

Nous pouvons recevoir des données d’un formulaire de demande Post via le PostForm méthode. Vous pouvez également utiliser le String ou JSON méthode pour renvoyer une chaîne ou des données JSON au client et spécifier le code d’état de la réponse.

// Register .

// @router /user/register/ [POST]

func Register(ctx context.Context, c *app.RequestContext) {

   var err error

   var req user.RegisterRequest

   err = c.BindAndValidate(&req)

   if err != nil {

      c.String(400, err.Error())

      return

   }

   resp := new(user.RegisterResponse)

   username := c.PostForm("username")

   password :=...