Erstellen Sie API-Dienste mit hoher Parallelität: Verwenden Sie zur Implementierung Go-Zero

Mit dem Aufkommen des Big-Data-Zeitalters wird die Datenmenge, die Unternehmen verarbeiten müssen, immer größer und die Verarbeitungsgeschwindigkeit wird immer schneller. Daher ist es sehr wichtig, API-Dienste mit hoher Parallelität zu erstellen. In diesem Artikel stellen wir vor, wie Sie das Go-Zero-Framework zum Erstellen von API-Diensten mit hoher Parallelität verwenden.

1. Was ist Go-Zero?

go-zero ist ein Microservice-Framework, das auf der Golang-Sprache basiert. Sein Ziel ist es, die Schwachstellen in der Microservice-Architektur zu lösen, wie z. B. komplexe Konfiguration, Middleware-Management, Service-Registrierung und andere Probleme. go-zero unterstützt den schnellen Aufbau leistungsstarker APIs, Middleware und RPC-Dienste und bietet einen umfangreichen Satz an Komponenten und Toolketten.

2. Warum Go-Zero verwenden?

Die Verwendung von Go-Zero kann die folgenden Vorteile bringen:

1. Hohe Leistung

Go-Zero nutzt eine große Anzahl von Optimierungstechnologien, einschließlich asynchroner E/A, zugrunde liegender Coroutine-Pool usw. Daher ist seine Leistung sehr hoch und es kann eine große Anzahl gleichzeitiger Anfragen verarbeiten.

2. Einfach zu erweitern

go-zero bietet eine große Anzahl an Komponenten und Toolketten, und Sie können Ihre eigenen Dienste schnell durch Konfigurationsdateien erweitern, ohne den Code neu schreiben zu müssen.

3. Hohe Zuverlässigkeit

go-zero nutzt viele stabile Technologien, wie z. B. Service-Registrierungszentren wie etcd und Consul, um die Zuverlässigkeit des gesamten Systems sicherzustellen.

4. Hohe Entwicklungseffizienz

Die API-Entwicklung von go-zero basiert auf Swagger/OpenAPI, sodass Dokumente und Clients generiert werden können, was die Entwicklungseffizienz verbessert.

3. Wie verwende ich Go-Zero, um einen API-Dienst mit hoher Parallelität aufzubauen?

Schritt 1: Go-Zero installieren

go-zero verwendet eine große Anzahl von Optimierungstechnologien, einschließlich asynchroner E/A, zugrunde liegender Coroutine-Pool usw. Daher ist seine Leistung sehr hoch und es kann eine große Anzahl gleichzeitiger Anfragen verarbeiten.

Schritt 2: API erstellen

Um eine einfache API zu erstellen, müssen wir ein API-Verzeichnis unter dem Projektverzeichnis erstellen und darin eine Datei erstellen, z. B. user.api, und dann den folgenden Inhalt in die Datei schreiben:

type (
    UserReq struct {
        Name  string `json:"name"`
        Age   int    `json:"age"`
        Email string `json:"email"`
    }

    UserResp struct {
        Id       int    `json:"id"`
        UserName string `json:"username"`
        Age      int    `json:"age"`
        Email    string `json:"email"`
    }

    UserApi interface {
        AddUser(ctx context.Context, req UserReq) (*UserResp, error)
        UpdateUser(ctx context.Context, id int, req UserReq) (*UserResp, error)
        GetUser(ctx context.Context, id int) (*UserResp, error)
    }
)

type (
    // 具体实现自己根据需要实现
    DefaultUserApi struct {
    }
)

func (ua *DefaultUserApi) AddUser(ctx context.Context, req UserReq) (*UserResp, error) {
    // 具体实现自己根据需要实现
    return nil, errors.New("not implement")
}

func (ua *DefaultUserApi) UpdateUser(ctx context.Context, id int, req UserReq) (*UserResp, error) {
    // 具体实现自己根据需要实现
    return nil, errors.New("not implement")
}

func (ua *DefaultUserApi) GetUser(ctx context.Context, id int) (*UserResp, error) {
    // 具体实现自己根据需要实现
    return nil, errors.New("not implement")
}

Schritt 3: Verwenden Sie goctl, um Code zu generieren

# 安装goctl
GO111MODULE=on GOPROXY=https://goproxy.io,direct go get -u github.com/tal-tech/go-zero/tools/goctl
# 生成代码
goctl api go -api user.api -dir .

generiert die Datei user.go im Verzeichnis, die unsere angepasste Struktur und Schnittstelle sowie einige von go-zero selbst generierte Strukturen und Funktionen enthält.

Schritt 4: Spezifische Logik implementieren

In der Datei user.go müssen wir unsere eigene spezifische Logik implementieren, zum Beispiel:

package api

import (
    "context"
    "errors"

    "github.com/tal-tech/go-zero/core/logx"
    "github.com/tal-tech/go-zero/rest/httpx"
)

type (
    UserReq struct {
        Name  string `json:"name"`
        Age   int    `json:"age"`
        Email string `json:"email"`
    }

    UserResp struct {
        Id       int    `json:"id"`
        UserName string `json:"username"`
        Age      int    `json:"age"`
        Email    string `json:"email"`
    }

    UserApi interface {
        AddUser(ctx context.Context, req UserReq) (*UserResp, error)
        UpdateUser(ctx context.Context, id int, req UserReq) (*UserResp, error)
        GetUser(ctx context.Context, id int) (*UserResp, error)
    }
)

type (
    // 具体实现自己根据需要实现
    DefaultUserApi struct {
    }
)

func (ua *DefaultUserApi) AddUser(ctx context.Context, req UserReq) (*UserResp, error) {
    // 具体实现
    logx.Info("add user:", req)
    return &UserResp{
        Id:       10001,
        UserName: req.Name,
        Age:      req.Age,
        Email:    req.Email,
    }, nil
}

func (ua *DefaultUserApi) UpdateUser(ctx context.Context, id int, req UserReq) (*UserResp, error) {
    // 具体实现
    logx.Info("update user:", id, req)
    return &UserResp{
        Id:       id,
        UserName: req.Name,
        Age:      req.Age,
        Email:    req.Email,
    }, nil
}

func (ua *DefaultUserApi) GetUser(ctx context.Context, id int) (*UserResp, error) {
    // 具体实现
    logx.Info("get user:", id)
    return &UserResp{
        Id:       id,
        UserName: "张三",
        Age:      25,
        Email:    "zhangsan@mail.com",
    }, nil
}

func (ua *DefaultUserApi) Error(ctx context.Context, err error) {
    httpx.Error(ctx, err)
}

Schritt 5: Konfigurationsdatei schreiben

Erstellen Sie ein etc-Verzeichnis im Projektstammverzeichnis , in dem Erstellen Sie eine Datei config.toml und schreiben Sie den folgenden Inhalt:

Name = "user"

[server]
Host = "0.0.0.0"
Port = 8888
Mode = "dev"

[etcd]
Hosts = [
    "127.0.0.1:2379"
]

[redis]
Host = "127.0.0.1:6379"
Type = "standalone"
Password = ""

Unter diesen stellen Host und Port unter Server die Adresse bzw. den Port des Dienstes dar, der lauscht, etcd stellt die Adresse des etcd-Registrierungszentrums dar und redis stellt die dar Adresse von Redis.

Schritt 6: Starten Sie den Dienst

Führen Sie den folgenden Befehl im Projektverzeichnis aus:

go run user.go -f etc/config.toml

bedeutet, den API-Dienst mit config.toml als Konfigurationsdatei zu starten.

Schritt 7: Testen Sie den Dienst

Verwenden Sie Curl und andere Tools, um eine Anfrage zu initiieren und zu testen, ob die API-Schnittstelle verfügbar ist. Beispiel:

curl localhost:8888/user -X POST -H "Content-Type: application/json" -d '{"name":"zhangsan", "age": 20, "email": "zhangsan@mail.com"}'

bedeutet, dass eine Anfrage an die POST-Methode von localhost:8888/user gesendet wird und der Anfragetext ein JSON-Objekt enthält.

Referenzmaterialien:

Offizielle Go-Zero-Dokumentation: https://go-zero.dev/

Go-Zero-Github-Adresse: https://github.com/tal-tech/go-zero

Das obige ist der detaillierte Inhalt vonErstellen Sie API-Dienste mit hoher Parallelität: Verwenden Sie zur Implementierung Go-Zero. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!