Vom Einstieg bis zur Kompetenz: Beherrschung des Go-Zero-Frameworks

Go-Zero ist ein hervorragendes Go-Sprachframework, das einen vollständigen Lösungssatz bietet, einschließlich RPC, Caching, geplante Aufgaben und andere Funktionen. Tatsächlich ist es sehr einfach, mit Go-Zero einen Hochleistungsdienst aufzubauen, und Sie können sogar in wenigen Stunden vom Anfänger zum Experten werden.

Dieser Artikel soll den Prozess der Erstellung leistungsstarker Dienste mithilfe des Go-Zero-Frameworks vorstellen und den Lesern helfen, die Kernkonzepte des Frameworks schnell zu verstehen.

1. Installation und Konfiguration

Bevor wir mit der Verwendung von Go-Zero beginnen, müssen wir es installieren und einige notwendige Umgebungen konfigurieren.

1. Installation

Die Installation von go-zero ist sehr einfach, führen Sie einfach den folgenden Befehl aus:

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

Dadurch wird automatisch die neueste Version von go-zero von GitHub heruntergeladen. Es ist jedoch zu beachten, dass die Verwendung von Go 1.13 und höher empfohlen wird.

2. Konfiguration

Bevor wir Go-Zero verwenden, müssen wir einige notwendige Umgebungen dafür konfigurieren. Insbesondere müssen wir das Befehlszeilentool goctl installieren, um Go-Zero zum Erstellen von Diensten verwenden zu können.

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

3. Projekt erstellen

Als nächstes müssen wir goctl verwenden, um ein neues Projekt zu erstellen. Wir gehen davon aus, dass das Projekt den Namen Blog trägt und mit dem folgenden Befehl erstellt werden kann:

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

Der obige Befehl erstellt ein neues API-Projekt und generiert einige erforderliche Dateien und Verzeichnisse.

2. Einen Dienst erstellen

Als nächstes können wir mit Go-Zero einen neuen Dienst erstellen. Wir gehen davon aus, dass der Dienstname user-service ist, der durch die folgenden Schritte erstellt werden kann:

1 Dienst generieren

Verwenden Sie goctl, um den Dienstcode von user-service zu generieren:

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

Der obige Befehl generiert einen Benutzer Verzeichnis im aktuellen Verzeichnis, das eine Datei namens user.go enthält, die den Dienstcode von user-service enthält.

2. Handler implementieren

Wir müssen auch eine spezifische Geschäftslogik implementieren, nämlich den Handler.

Zuerst müssen wir ein neues Verzeichnis mit dem Namen handler unter dem Benutzerverzeichnis erstellen und darin eine Datei mit dem Namen userhandler.go erstellen. Diese Datei enthält unseren Handler-Code. Der Code von

userhandler.go lautet wie folgt:

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)
    }
}

Der obige Code verwendet das von go-zero bereitgestellte rest/httpx-Paket, das einige praktische Funktionen wie NewRequest, WriteError und WriteJSON usw. bereitstellt, was den HTTP-Dienst vereinfacht Schreibprozess.

3. Handler registrieren

Jetzt müssen wir das obige Handlerprogramm im Dienst registrieren.

Fügen Sie in der Init-Methode in der Datei user.go den folgenden Code hinzu:

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

Der obige Code registriert die userHandler-Funktion als HTTP-Dienst, und wir können auf diesen Dienst zugreifen, indem wir eine Route in der API-Datei definieren.

3. Erstellen Sie eine Vorlage

Wir können über goctl create api eine neue Go-Zero-API generieren, die automatisch einen Ordner mit einigen Initialisierungskonfigurationen erstellt. Wir können unseren eigenen Controller und Dienst entsprechend den Anforderungen von goctl hinzufügen.

Hier erstellen wir eine Vorlagenanwendung, um besser zu lernen, den Quellcode von Go-Zero zu lesen. Die Anwendung enthält ein CRUD-Beispiel, das die Verwendung der allgemeinen Funktionen von Go-Zero demonstriert.

1. Vorlage generieren

Wir können goctl verwenden, um eine Vorlagenanwendung zu generieren, um den Quellcode von Go-Zero besser zu lernen.

$ goctl api template -o app.go

Der obige Befehl erstellt eine Datei namens app.go, die den gesamten Quellcode der Vorlagenanwendung enthält.

2. Datenzugriff implementieren

Wir gehen davon aus, dass MySQL zur Datenspeicherung verwendet wird. Vor dem Start muss MySQL installiert und konfiguriert werden. Auf dieser Basis können wir go-sql verwenden, das von go-zero bereitgestellt wird, um die Datenbankzugriffsschicht aufzubauen.

Konkret können wir goctl verwenden, um den Code der Datenzugriffsschicht zu generieren:

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

Der obige Befehl generiert eine userModel.go-Datei, die das Benutzerdatenmodell für den Datenzugriff enthält.

3. Geschäftslogik implementieren

Als nächstes müssen wir die Geschäftslogik implementieren und sie in Verbindung mit der Datenzugriffsschicht verwenden. Konkret können wir eine Datei namens userLogic.go erstellen, die Geschäftslogik für die Benutzerverwaltung enthält. Der

userLogic.go-Code lautet wie folgt:

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
}

Im obigen Code haben wir die SQLX-, Stores- und LogX-Pakete eingeführt, wobei SQLX Teil des Go-Zero-Frameworks ist und speziell für Datenbankoperationen verwendet wird. Stores ist die Datenspeicherschicht des Go-Zero-Frameworks. Das Logx-Paket ist eine vom Go-Zero-Framework bereitgestellte Protokollierungsbibliothek, die uns bei der Aufzeichnung wichtiger Ereignisse helfen kann.

4. Integrieren Sie ETCD usw.

Mit dem Go-Zero-Framework können wir einige häufig verwendete Tools und Dienste wie ETCD, Redis, ZooKeeper usw. problemlos integrieren. Konkret können wir die von go-zero bereitgestellten relevanten Bibliotheken in den Code importieren und die relevanten Informationen in der Konfigurationsdatei konfigurieren.

Hier sind einige häufig verwendete Integrationsmethoden:

1. ETCD integrieren

Fügen Sie zunächst die folgenden Informationen in die Konfigurationsdatei ein:

[etcd]
host = "localhost:2379"

Verwenden Sie dann in dem Code, in dem Sie ETCD verwenden möchten, die Funktion clientv3.New um einen neuen etcd-Client zu erstellen.

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)
}

Der obige Code erstellt einen ETCD-Client namens client, der localhost:2379 als Adresse des ETCD-Servers verwendet.

2. Redis integrieren

Um Redis zu verwenden, müssen wir die folgenden Informationen zur Konfigurationsdatei hinzufügen:

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

Dann verwenden Sie in dem Code, in dem Sie Redis verwenden möchten, die Funktion redis.NewClient, um ein neues Redis zu erstellen Kunde.

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

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

Der obige Code erstellt einen neuen Redis-Client, der localhost:6379 als Redis-Serveradresse, kein Passwort und die Standard-Datenbank verwendet.

3. Integrieren Sie 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框架用于您的下一个项目吧，它将使您能够构建出更加灵活、高效和可靠的服务！

Das obige ist der detaillierte Inhalt vonVom Einstieg bis zur Kompetenz: Beherrschung des Go-Zero-Frameworks. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!