Dari kemasukan kepada kemahiran: Menguasai rangka kerja go-zero

Go-zero ialah rangka kerja bahasa Go yang sangat baik yang menyediakan set penyelesaian lengkap, termasuk RPC, caching, tugas berjadual dan fungsi lain. Sebenarnya, sangat mudah untuk membina perkhidmatan berprestasi tinggi menggunakan go-zero, malah anda boleh pergi dari pemula kepada mahir dalam beberapa jam.

Artikel ini bertujuan untuk memperkenalkan proses membina perkhidmatan berprestasi tinggi menggunakan rangka kerja go-zero dan membantu pembaca memahami dengan cepat konsep teras rangka kerja tersebut.

1. Pemasangan dan konfigurasi

Sebelum mula menggunakan go-zero, kami perlu memasangnya dan mengkonfigurasi beberapa persekitaran yang diperlukan.

1. Pemasangan

Memasang go-zero adalah sangat mudah, cuma jalankan arahan berikut:

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

Ini akan memuat turun versi terbaharu go-zero daripada GitHub . Walau bagaimanapun, perlu diingatkan bahawa disyorkan untuk menggunakan Go 1.13 dan ke atas.

2. Konfigurasi

Sebelum menggunakan go-zero, kita perlu mengkonfigurasi beberapa persekitaran yang diperlukan untuknya. Khususnya, kita perlu memasang alat baris arahan goctl untuk menggunakan go-zero untuk mencipta perkhidmatan.

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

3. Cipta projek

Seterusnya, kita perlu menggunakan goctl untuk mencipta projek baharu. Kami menganggap bahawa projek itu dinamakan blog dan boleh dibuat dengan arahan berikut:

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

Perintah di atas akan mencipta projek API baharu dan menjana beberapa fail dan direktori yang diperlukan.

2. Buat perkhidmatan

Seterusnya, kita boleh menggunakan go-zero untuk mencipta perkhidmatan baharu. Kami menganggap bahawa nama perkhidmatan ialah perkhidmatan pengguna, yang boleh dibuat melalui langkah berikut:

1 Jana perkhidmatan

Gunakan goctl untuk menjana kod perkhidmatan perkhidmatan pengguna: <🎜. >

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

Arahan di atas Direktori pengguna akan dijana dalam direktori semasa, mengandungi fail bernama user.go, yang mengandungi kod perkhidmatan perkhidmatan pengguna.

2. Implement handler

Kita juga perlu melaksanakan logik perniagaan tertentu, iaitu pengendali.

Pertama, kita perlu mencipta direktori baharu bernama pengendali di bawah direktori pengguna dan mencipta fail bernama userhandler.go di dalamnya. Fail ini akan mengandungi kod pengendali kami.

kod userhandler.go adalah seperti berikut:

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

Kod di atas menggunakan pakej selebihnya/httpx yang disediakan oleh go-zero, yang menyediakan beberapa fungsi mudah, seperti NewRequest, WriteError dan WriteJSON, dsb. Proses penulisan perkhidmatan HTTP yang dipermudahkan.

3. Daftar pengendali

Sekarang kita perlu mendaftarkan program pengendali di atas ke dalam perkhidmatan.

Dalam kaedah init dalam fail user.go, tambah kod berikut:

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

Kod di atas mendaftarkan fungsi userHandler sebagai perkhidmatan HTTP, kami boleh mengaksesnya dengan menentukan laluan dalam fail API Serve.

3. Cipta templat

Kami boleh menjana API go-zero baharu melalui goctl create api, yang secara automatik akan mencipta folder yang mengandungi beberapa konfigurasi permulaan. Kami boleh menambah pengawal dan perkhidmatan kami sendiri di dalamnya mengikut keperluan goctl.

Di sini kami mencipta aplikasi templat untuk belajar membaca kod sumber go-zero dengan lebih baik. Aplikasi ini akan mengandungi contoh CRUD yang menunjukkan cara menggunakan ciri biasa go-zero.

1. Jana templat

Kita boleh menggunakan goctl untuk menjana aplikasi templat untuk mempelajari kod sumber go-zero dengan lebih baik.

$ goctl api template -o app.go

Arahan di atas akan mencipta fail bernama app.go yang mengandungi semua kod sumber aplikasi templat.

2. Laksanakan akses data

Kami menganggap bahawa MySQL digunakan untuk penyimpanan data. Sebelum memulakan, MySQL perlu dipasang dan dikonfigurasikan. Atas dasar ini, kita boleh menggunakan go-sql yang disediakan oleh go-zero untuk membina lapisan akses pangkalan data.

Secara khusus, kita boleh menggunakan goctl untuk menjana kod lapisan akses data:

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

Arahan di atas akan menjana fail userModel.go yang mengandungi model data pengguna untuk akses data.

3. Laksanakan logik perniagaan

Seterusnya, kita perlu melaksanakan logik perniagaan dan menggunakannya bersama dengan lapisan akses data. Khususnya, kami boleh mencipta fail bernama userLogic.go yang mengandungi logik perniagaan untuk pengurusan pengguna.

kod userLogic.go adalah seperti berikut:

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
}

Dalam kod di atas, kami memperkenalkan pakej sqlx, kedai dan logx, di mana sqlx adalah sebahagian daripada rangka kerja go-zero dan digunakan secara khusus untuk operasi pangkalan data. stor ialah lapisan storan data rangka kerja go-zero. Pakej logx ialah perpustakaan pengelogan yang disediakan oleh rangka kerja go-zero, yang boleh membantu kami merekodkan peristiwa penting.

4. Integrasikan ETCD, dsb.

Menggunakan rangka kerja go-zero, kami boleh dengan mudah menyepadukan beberapa alatan dan perkhidmatan yang biasa digunakan, seperti ETCD, Redis, ZooKeeper, dsb. Secara khusus, kami boleh mengimport perpustakaan berkaitan yang disediakan oleh go-zero dalam kod dan mengkonfigurasi maklumat yang berkaitan dalam fail konfigurasi.

Berikut ialah beberapa kaedah penyepaduan yang biasa digunakan:

1 Integrasikan ETCD

Mula-mula, tambah maklumat berikut dalam fail konfigurasi:

rreee

Kemudian. , dalam Untuk menggunakan kod etcd, gunakan fungsi clientv3.New untuk mencipta klien etcd baharu.

[etcd]
host = "localhost:2379"

Kod di atas akan mencipta klien ETCD bernama klien, yang akan menggunakan localhost:2379 sebagai alamat pelayan ETCD.

2. Integrasikan Redis

Untuk menggunakan Redis, kami perlu menambah maklumat berikut dalam fail konfigurasi:

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

Kemudian, dalam kod yang anda mahu gunakan Redis , gunakan redis Fungsi NewClient mencipta klien Redis baharu.

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

Kod di atas akan mencipta klien Redis baharu, yang akan menggunakan localhost:6379 sebagai alamat pelayan Redis, tiada kata laluan dan menggunakan DB lalai.

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

Atas ialah kandungan terperinci Dari kemasukan kepada kemahiran: Menguasai rangka kerja go-zero. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!