De l’entrée à la compétence : maîtriser le cadre go-zero

Go-zero est un excellent framework de langage Go qui fournit un ensemble complet de solutions, notamment RPC, mise en cache, tâches planifiées et autres fonctions. En fait, il est très simple de créer un service performant en utilisant go-zero, et vous pouvez même passer de débutant à compétent en quelques heures.

Cet article vise à présenter le processus de création de services hautes performances à l'aide du framework go-zero et à aider les lecteurs à comprendre rapidement les concepts de base du framework.

1. Installation et configuration

Avant de commencer à utiliser go-zero, nous devons l'installer et configurer certains environnements nécessaires.

1. Installation

L'installation de go-zero est très simple, exécutez simplement la commande suivante :

$ go get -u github.com/tal-tech/go-zero

Cela téléchargera automatiquement la dernière version de go-zero depuis GitHub. Cependant, il convient de noter qu'il est recommandé d'utiliser Go 1.13 et supérieur.

2. Configuration

Avant d'utiliser go-zero, nous devons configurer certains environnements nécessaires pour celui-ci. Plus précisément, nous devons installer l'outil de ligne de commande goctl afin d'utiliser go-zero pour créer des services.

$ GO111MODULE=on go get -u github.com/tal-tech/go-zero/tools/goctl

3. Créer un projet

Ensuite, nous devons utiliser goctl pour créer un nouveau projet. Nous supposons que le projet s'appelle blog et peut être créé avec la commande suivante :

$ mkdir blog
$ cd blog
$ go mod init blog
$ goctl api new blog

La commande ci-dessus créera un nouveau projet API et générera certains fichiers et répertoires nécessaires.

2. Créer un service

Ensuite, nous pouvons utiliser go-zero pour créer un nouveau service. Nous supposons que le nom du service est user-service, qui peut être créé en suivant les étapes suivantes :

1. Générer le service

Utilisez goctl pour générer le code de service du user-service :

$ goctl api go -api user.api -dir .

La commande ci-dessus générera un utilisateur. répertoire dans le répertoire courant, qui contient Un fichier nommé user.go, qui contient le code de service de user-service.

2. Implémenter le gestionnaire

Nous devons également implémenter une logique métier spécifique, qui est le gestionnaire.

Tout d'abord, nous devons créer un nouveau répertoire nommé handler sous le répertoire utilisateur et y créer un fichier nommé userhandler.go. Ce fichier contiendra notre code de gestionnaire.

Le code userhandler.go est le suivant :

package handler

import (
    "net/http"

    "github.com/tal-tech/go-zero/rest/httpx"
    "blog/service/user/api/internal/logic"
    "blog/service/user/api/internal/svc"
)

func userHandler(ctx *svc.ServiceContext) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        req, err := httpx.NewRequest(r)
        if err != nil {
            httpx.WriteError(w, err)
            return
        }

        l := logic.NewUserLogic(r.Context(), ctx)
        resp, err := l.GetUser(req)
        if err != nil {
            httpx.WriteError(w, err)
            return
        }

        httpx.WriteJson(w, resp)
    }
}

Le code ci-dessus utilise le package rest/httpx fourni par go-zero, qui fournit des fonctions pratiques, telles que NewRequest, WriteError et WriteJSON, etc., ce qui simplifie le service HTTP. processus d'écriture.

3. Enregistrer le gestionnaire

Nous devons maintenant enregistrer le programme de gestion ci-dessus dans le service.

Dans la méthode init du fichier user.go, ajoutez le code suivant :

func (s *Service) InitHandlers() {
    s.UserHandler = http.HandlerFunc(handler.UserHandler(s.Context))
}

Le code ci-dessus enregistre la fonction userHandler en tant que service HTTP, et nous pouvons accéder à ce service en définissant une route dans le fichier API.

3. Créer un modèle

Nous pouvons générer une nouvelle API go-zero via goctl create api, qui créera automatiquement un dossier contenant certaines configurations d'initialisation. Nous pouvons y ajouter notre propre contrôleur et service selon les exigences de goctl.

Ici, nous créons un modèle d'application pour mieux apprendre à lire le code source de go-zero. L'application contiendra un exemple CRUD montrant comment utiliser les fonctionnalités communes de go-zero.

1. Générer un modèle

Nous pouvons utiliser goctl pour générer une application modèle afin de mieux apprendre le code source de go-zero.

$ goctl api template -o app.go

La commande ci-dessus créera un fichier appelé app.go qui contient tout le code source de l'application modèle.

2. Implémenter l'accès aux données

Nous supposons que MySQL est utilisé pour le stockage des données. Avant de démarrer, MySQL doit être installé et configuré. Sur cette base, nous pouvons utiliser go-sql fourni par go-zero pour construire la couche d'accès à la base de données.

Plus précisément, nous pouvons utiliser goctl pour générer le code de la couche d'accès aux données :

$ goctl model mysql datasource "root:123456@tcp(127.0.0.1:3306)/test" -table user -dir .

La commande ci-dessus générera un fichier userModel.go qui contient le modèle de données utilisateur pour l'accès aux données.

3. Implémenter la logique métier

Ensuite, nous devons implémenter la logique métier et l'utiliser en conjonction avec la couche d'accès aux données. Plus précisément, nous pouvons créer un fichier appelé userLogic.go qui contient la logique métier pour la gestion des utilisateurs. Le code

userLogic.go est le suivant :

package logic

import (
    "context"
    "github.com/tal-tech/go-zero/core/logx"
    "github.com/tal-tech/go-zero/core/stores/sqlx"
    "blog/service/user/model"
    "blog/service/user/api/internal/svc"
    "blog/service/user/api/internal/types"
)

type UserLogic struct {
    ctx context.Context
    svcCtx *svc.ServiceContext
    logx.Logger
}

func NewUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) UserLogic {
    return UserLogic{
        ctx: ctx,
        svcCtx: svcCtx,
        Logger: logx.WithContext(ctx),
    }
}

func (l *UserLogic) GetUser(req types.GetUserRequest) (*types.GetUserResponse, error) {
    //Todo
}

Dans le code ci-dessus, nous avons introduit les packages sqlx, stores et logx, où sqlx fait partie du framework go-zero et est spécifiquement utilisé pour les opérations de base de données. stores est la couche de stockage de données du framework go-zero. Le package logx est une bibliothèque de journalisation fournie par le framework go-zero, qui peut nous aider à enregistrer des événements importants.

4. Intégrer ETCD, etc.

En utilisant le framework go-zero, nous pouvons facilement intégrer certains outils et services couramment utilisés, tels que ETCD, Redis, ZooKeeper, etc. Plus précisément, nous pouvons importer les bibliothèques pertinentes fournies par go-zero dans le code et configurer les informations pertinentes dans le fichier de configuration.

Voici quelques méthodes d'intégration couramment utilisées :

1. Intégrez ETCD

Tout d'abord, ajoutez les informations suivantes dans le fichier de configuration :

[etcd]
host = "localhost:2379"

Ensuite, dans le code où vous souhaitez utiliser ETCD, utilisez la fonction clientv3.New. pour en créer un nouveau client etcd.

import (
    "go.etcd.io/etcd/clientv3"
)

client, err := clientv3.New(clientv3.Config{
    Endpoints:   []string{"localhost:2379"},
    DialTimeout: 5 * time.Second,
})
if err != nil {
    panic(err)
}

Le code ci-dessus créera un client ETCD nommé client, qui utilisera localhost:2379 comme adresse du serveur ETCD.

2. Intégrer Redis

Pour utiliser Redis, nous devons ajouter les informations suivantes au fichier de configuration :

[redis]
host = "localhost:6379"
password = ""
db = 0

Ensuite, dans le code où vous souhaitez utiliser Redis, utilisez la fonction redis.NewClient pour créer un nouveau Redis. client.

import (
    "github.com/go-redis/redis"
)

client := redis.NewClient(&redis.Options{
    Addr:     "localhost:6379",
    Password: "", // no password set
    DB:       0,  // use default DB
})

Le code ci-dessus créera un nouveau client Redis, qui utilisera localhost:6379 comme adresse du serveur Redis, pas de mot de passe et utilisera la base de données par défaut.

3. Intégrez ZooKeeper

要使用ZooKeeper，我们需要在配置文件中添加以下信息：

[zookeeper]
host = "localhost:2181"

然后，在要使用ZooKeeper的代码中，使用zk.Connect函数创建一个新的ZooKeeper客户端。

import (
    "github.com/samuel/go-zookeeper/zk"
    "time"
)

conn, _, err := zk.Connect([]string{"localhost:2181"}, time.Second*5)
if err != nil {
    panic(err)
}

上述代码将创建一个名为conn的ZooKeeper客户端，它将使用localhost:2181作为ZooKeeper服务器的地址。

五、总结

到目前为止，我们已经深入了解了go-zero框架，并学到了如何使用它来构建高性能服务。

总结一下，要使用go-zero，请先安装和配置相关环境，然后创建一个新的项目，通过goctl命令行工具自动生成模板代码和配置文件。

接着，可以使用go-zero提供的各种功能和服务来逐步完善和扩展我们的应用程序，如集成数据库、ETCD、Redis等。

将go-zero框架用于您的下一个项目吧，它将使您能够构建出更加灵活、高效和可靠的服务！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!