Terangkan prinsip teras dan penggunaan pelaksanaan golang Jimat

Thrift ialah rangka kerja perkhidmatan jauh berbilang bahasa berbilang perkhidmatan Ia menyokong penggunaan bahasa penerangan antara muka yang ditakrifkan oleh IDL untuk mentakrifkan antara muka RPC merentas bahasa. Antaranya, pelaksanaan golang Thrift menyediakan rangka kerja RPC yang ringan dan cekap, yang telah digunakan secara meluas dalam sistem teragih. Artikel ini akan menerangkan prinsip teras dan penggunaan pelaksanaan golang Thrift.

1. Prinsip kerja pelaksanaan Thrift golang

Thrift menggunakan bahasa IDL untuk mentakrif antara muka, dan menjana kod antara muka dalam pelbagai bahasa melalui penjana kod, dan kemudian menggunakan protokol RPC untuk berkomunikasi antara komunikasi bahasa yang berbeza. Pelaksanaan golang Thrift juga menggunakan idea ini, menggunakan alat gothrift untuk menjana kod antara muka bahasa Go untuk melaksanakan komunikasi RPC antara bahasa yang berbeza.

Secara khusus, menggunakan pelaksanaan golang Thrift memerlukan langkah berikut:

1 Tentukan fail antara muka IDL

Pertama, anda perlu mentakrifkan fail antara muka menggunakan bahasa IDL, khususnya. Untuk sintaks, sila rujuk dokumentasi rasmi Thrift. Berikut ialah contoh IDL mudah:

namespace go thrift.demo

struct Person {
    1: i32 Id
    2: string Name
    3: i32 Age
}

service DemoService {
    void SayHello()
    i32 Add(1:i32 a, 2:i32 b)
    Person GetPerson(1:i32 id)
}

Fail IDL di atas mentakrifkan Perkhidmatan bernama "DemoService", yang mengandungi tiga kaedah "SayHello", "Add" dan "GetPerson". Antaranya, parameter kaedah "Tambah" termasuk dua parameter integer a dan b, dan nilai pulangan ialah integer. Parameter kaedah "GetPerson" ialah id integer dan mengembalikan struktur "Orang".

2. Jana kod Go

Seterusnya, anda perlu menggunakan alat gothrift untuk menjana kod antara muka golang yang sepadan. Langkah-langkah khusus adalah seperti berikut:

• Pasang gothrift

Gunakan alat baris arahan go untuk memasang gothrift:

go get github.com/apache/thrift/lib/go/thrift

• Laksanakan gothrift

Gunakan fail IDL yang dijana untuk melaksanakan gothrift untuk menjana kod Go:

gothrift --out=./gen --template=go thrift-demo.thrift

Selepas melaksanakan arahan di atas, fail kod golang akan dijana.

3. Laksanakan perkhidmatan antara muka

Selepas mendapatkan kod antara muka golang yang dijana, anda perlu melaksanakan perkhidmatan antara muka ini. Berikut ialah beberapa contoh pelaksanaan:

type demoServiceImpl struct{}

func (demoServiceImpl) SayHello(ctx context.Context) (err error) {
    fmt.Println("Hello World")
    return
}

func (demoServiceImpl) Add(ctx context.Context, a, b int32) (int32, error) {
    return a + b, nil
}

func (demoServiceImpl) GetPerson(ctx context.Context, id int32) (*Person, error) {
    person := &Person{
        Id: id,
        Name: "张三",
        Age: 25,
    }
    return person, nil
}

Dalam kod di atas, jenis bernama "demoServiceImpl" ditakrifkan dan tiga kaedah "SayHello", "Add" dan "GetPerson" dilaksanakan.

4. Buka perkhidmatan

Selepas melengkapkan pelaksanaan perkhidmatan antara muka, anda perlu membuka perkhidmatan untuk panggilan jauh. Berikut ialah beberapa contoh kod:

transportFactory := thrift.NewTBufferedTransportFactory(8192)
protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
addr := "localhost:9091"
transport, err := thrift.NewTServerSocket(addr)
if err != nil {
    return
}
handler := &demoServiceImpl{}
processor := demo.NewDemoServiceProcessor(handler)
server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory)
server.Serve()

Dalam kod di atas, mula-mula gunakan "NewTBufferedTransportFactory" dan "NewTBinaryProtocolFactoryDefault" untuk mencipta objek transportFactory dan protocolFactory. Kemudian gunakan "NewTServerSocket" untuk membuka ServerSocket pada alamat yang ditentukan. Kemudian masukkan objek "demoServiceImpl" yang melaksanakan antara muka "DemoService" dan buat pemproses "DemoServiceProcessor". Akhir sekali, gunakan "NewTSimpleServer4" untuk membolehkan pemantauan perkhidmatan.

2. Cara menggunakan pelaksanaan Thrift golang

Berikut memperkenalkan cara menggunakan pelaksanaan Thrift golang:

1 daripada Jimat dan pasang.

2. Cipta fail IDL

Gunakan bahasa IDL untuk mentakrifkan fail antara muka dan mentakrifkan kaedah antara muka dan jenis data.

3. Hasilkan kod antara muka Golang

Gunakan alat gothrift untuk menjana kod antara muka Golang.

4. Laksanakan perkhidmatan antara muka

Tulis kod pelaksanaan perkhidmatan antara muka berdasarkan definisi antara muka yang dihasilkan.

5 Dayakan perkhidmatan

Menurut kod sampel, dayakan pemantauan pelayan Thrift.

6. Antara muka panggilan pelanggan

Klien jimat membuat panggilan jauh melalui kod antara muka Golang yang dihasilkan. Berikut ialah contoh kod mudah:

Dalam kod di atas, mula-mula buat objek pengangkutan pelanggan dan sambungkan ke pelayan Thrift. Kemudian buat objek klien "NewDemoServiceClientFactory" dan gunakan kaedah "SayHello", "Add" dan "GetPerson" untuk membuat panggilan jauh.

transport, err := thrift.NewTSocket("localhost:9091")
if err != nil {
    panic(err)
}
if err := transport.Open(); err != nil {
    panic(err)
}
defer transport.Close()

protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
client := demo.NewDemoServiceClientFactory(transport, protocolFactory)
if err := client.SayHello(context.Background()); err != nil {
    panic(err)
}
res, _ := client.Add(context.Background(), 1, 2)
fmt.Println(res)
person, _ := client.GetPerson(context.Background(), 1)
fmt.Println(person)

Ringkasan:

Artikel ini memperkenalkan prinsip kerja dan penggunaan pelaksanaan Golang Jimat. Menggunakan Thrift untuk melaksanakan RPC secara berkesan boleh mengurangkan kos pembangunan dan mempercepatkan kemajuan pembangunan sistem. Pelaksanaan golang Thrift ialah rangka kerja RPC yang ringan dan cekap yang digunakan secara meluas dalam sistem teragih.

Atas ialah kandungan terperinci Terangkan prinsip teras dan penggunaan pelaksanaan golang Jimat. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!