Kaedah aplikasi rpc dan tenang dalam fungsi Golang

Golang ialah bahasa pengaturcaraan yang sangat ringkas, cekap dan sangat sesuai yang telah menjadi semakin popular di kalangan pembangun sejak beberapa tahun kebelakangan ini. Di Golang, fungsi adalah elemen pengaturcaraan yang sangat biasa digunakan Pelbagai fungsi boleh dilaksanakan melalui fungsi, seperti pengiraan, aliran kawalan, pemprosesan data, dll. Dalam artikel ini, saya akan memperkenalkan kaedah aplikasi rpc dan restful fungsi Golang.

1. pengenalan rpc

RPC (Panggilan Prosedur Jauh) ialah protokol panggilan prosedur jauh yang matlamatnya adalah untuk membantu aplikasi berjalan antara komputer yang berbeza atau sistem pengendalian yang berbeza . Kelebihan RPC ialah ia membolehkan aplikasi memanggil proses program jauh secara tempatan, sama seperti memanggil program tempatan secara tempatan, menjadikan pembangunan aplikasi yang diedarkan lebih mudah.

Di Golang, kami boleh melaksanakan invokasi kaedah jauh melalui rpc. Pelaksanaan rpc perlu mengikut langkah berikut:

1) Tentukan fungsi yang perlu didedahkan kepada panggilan daripada program lain.

2) Gunakan pakej rpc dalam pustaka standard Go untuk mendaftarkan fungsi sebagai perkhidmatan RPC boleh panggil.

3) Daftarkan perkhidmatan RPC ke pelayan supaya program lain boleh memanggil perkhidmatan melalui rangkaian dan mendapatkan nilai pulangan.

Berikut ialah contoh kod ringkas yang menunjukkan cara menggunakan rpc untuk melaksanakan penyeruan kaedah jauh di Golang:

package main

import (
    "fmt"
    "log"
    "net"
    "net/rpc"
)

type Args struct {
    A, B int
}

type Result struct {
    Value int
}

type Math struct {}

func (m *Math) Multiply(args *Args, result *Result) error {
    result.Value = args.A * args.B
    return nil
}

func main() {
    math := new(Math)
    rpc.Register(math)
    l, e := net.Listen("tcp", ":1234")
    if e != nil {
        log.Fatal("listen error:", e)
    }
    for {
        conn, err := l.Accept()
        if err != nil {
            log.Fatal(err)
        }
        go rpc.ServeConn(conn)
    }
}

Kod di atas mentakrifkan struktur Matematik dan kaedahnya Darab, Mewakili perkhidmatan RPC yang boleh mendarab dua integer. Antaranya, kaedah Multiply menerima parameter jenis Args dan nilai pulangan jenis Result, dan menyimpan hasil darab parameter dalam nilai pulangan.

Dalam fungsi utama, kami mendaftarkan matematik pembolehubah jenis Matematik sebagai perkhidmatan RPC. Kemudian dengarkan port tempatan 1234 dan tunggu program lain memanggil perkhidmatan melalui rangkaian. Apabila panggilan berjaya, nilai pulangan akan disimpan dalam hasil pembolehubah.

2. Pengenalan kepada tenang

Restful ialah gaya seni bina aplikasi rangkaian berdasarkan protokol HTTP Ia terutamanya berorientasikan sumber dan menggunakan URI (pengecam sumber seragam). alamat. Akses sumber dan capai interaksi data dan pemindahan status melalui GET, POST, PUT, DELETE dan kaedah protokol HTTP yang lain. Seni bina gaya RESTful adalah ringan, fleksibel dan mudah untuk dilaksanakan.

Di Golang, kami juga boleh menggunakan restful untuk melaksanakan interaksi data dan pemindahan keadaan aplikasi web. Pelaksanaan restful perlu mengikut langkah berikut:

1) Tentukan fungsi yang perlu didedahkan kepada panggilan daripada program lain, dan nyatakan kaedah permintaan dan laluan akses yang akan dikendalikan oleh fungsi tersebut.

2) Gunakan pakej net/http dalam pustaka standard Go untuk mendaftarkan fungsi sebagai perkhidmatan rehat yang boleh dipanggil.

Berikut ialah contoh kod ringkas yang menunjukkan cara menggunakan restful di Golang untuk melaksanakan interaksi data dalam aplikasi web:

package main

import (
    "encoding/json"
    "log"
    "net/http"

    "github.com/gorilla/mux"
)

type Todo struct {
    ID        string `json:"id,omitempty"`
    Title     string `json:"title,omitempty"`
    Completed bool   `json:"completed,omitempty"`
}

var todos []Todo

func GetTodos(w http.ResponseWriter, r *http.Request) {
    json.NewEncoder(w).Encode(todos)
}

func AddTodo(w http.ResponseWriter, r *http.Request) {
    var todo Todo
    _ = json.NewDecoder(r.Body).Decode(&todo)
    todos = append(todos, todo)
    json.NewEncoder(w).Encode(todo)
}

func main() {
    router := mux.NewRouter()

    todos = append(todos, Todo{ID: "1", Title: "Todo 1", Completed: false})
    todos = append(todos, Todo{ID: "2", Title: "Todo 2", Completed: true})

    router.HandleFunc("/todos", GetTodos).Methods("GET")
    router.HandleFunc("/todos", AddTodo).Methods("POST")

    log.Fatal(http.ListenAndServe(":8000", router))
}

Kod di atas mentakrifkan dua kaedah GetTodos dan AddTodo, Mewakili mendapatkan Todo senaraikan dan tambah Todo baharu. Dalam fungsi utama, kami mendaftarkan kedua-dua kaedah ini sebagai perkhidmatan tenang melalui penghala, mendengar port tempatan 8000, dan menunggu aplikasi web memanggil perkhidmatan melalui permintaan HTTP.

Apabila aplikasi web meminta untuk mendapatkan senarai Todo, kaedah GetTodos akan dilaksanakan dan mengembalikan semua data dalam pembolehubah todos. Apabila aplikasi web meminta untuk menambah Todo baharu, kaedah AddTodo akan dilaksanakan dan Todo baharu akan ditambahkan pada pembolehubah todos.

Melalui contoh kod di atas, kita dapat melihat bahawa proses menggunakan rpc dan restful untuk melaksanakan invokasi kaedah jauh dan interaksi data aplikasi web di Golang adalah sangat mudah dan intuitif. Fungsi ini bukan sahaja dapat membantu kami merealisasikan pembangunan aplikasi yang diedarkan, tetapi juga menjadikan pembangunan aplikasi Web lebih cekap dan fleksibel.

Atas ialah kandungan terperinci Kaedah aplikasi rpc dan tenang dalam fungsi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!