golang api build

Golang ialah bahasa pengaturcaraan yang direka khas untuk membina perkhidmatan konkurensi tinggi dan aplikasi rangkaian. Golang mempunyai keupayaan konkurensi dan pengaturcaraan rangkaian yang cekap, yang menjadikannya pilihan pertama banyak pembangun. Untuk membina API Golang, kita perlu menguasai banyak konsep dan kemahiran asas, daripada pemprosesan penghalaan kepada akses pangkalan data dan banyak lagi. Artikel ini akan memperkenalkan cara menggunakan Golang untuk membina API.

1. Persediaan persekitaran

Sebelum anda mula membina API Golang, anda perlu memasang Golang pada komputer anda. Anda boleh memuat turun versi terkini Golang melalui tapak web rasmi Golang (https://golang.org/), atau memasangnya melalui pengurus pakej, seperti apt-get atau yum, dsb. Selepas pemasangan selesai, masukkan "versi pergi" dalam terminal untuk mengesahkan sama ada pemasangan berjaya.

2. Pemasangan pakej dependency

Gunakan arahan "go get" dalam terminal untuk memasang pakej dependency yang diperlukan. Pakej bergantung ialah beberapa perpustakaan yang sering kami gunakan dalam API, seperti "gorilla/mux" dan "gorm". Kaedah pemasangan adalah seperti berikut:

go get github.com/gorilla/mux 
go get github.com/jinzhu/gorm 
go get github.com/go-sql-driver/mysql

3 Pemprosesan penghalaan

Semua permintaan API perlu diselesaikan melalui penghalaan. Salah satu pakej penghalaan yang paling popular di Golang ialah gorila/mux, jadi kami akan menggunakannya juga.

Untuk menggunakan gorila/mux, kita perlu mengimport pakej dan mencipta objek mux baharu. Dalam contoh ini, kami akan mencipta dua laluan, satu untuk memaparkan halaman utama API dan satu lagi untuk mengendalikan permintaan GET kami.

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/mux"
)

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

    router.HandleFunc("/", Index)
    router.HandleFunc("/tasks", getTasks).Methods("GET")

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

func Index(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Welcome to my API!")
}

func getTasks(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "You have requested all tasks")
}

Dalam kod di atas, kami mencipta dua fungsi pengendali, Indeks dan getTasks. Fungsi Indeks digunakan untuk memaparkan halaman utama API dan getTasks mengendalikan semua permintaan GET.

4. Akses pangkalan data

Kini kami akan menambah fungsi pangkalan data pada API. Dalam contoh ini, kami akan menggunakan pangkalan data MySQL dan menggunakan perpustakaan gorm untuk mengurus data.

Pertama, kita perlu membuat sambungan pangkalan data. Untuk melakukan ini, kita perlu mencipta struct Pangkalan Data yang mengandungi butiran sambungan. Seterusnya, kami akan mencipta fungsi "openDB" baharu untuk membuka sambungan.

...

import (
    "database/sql"
    "log"

    _ "github.com/go-sql-driver/mysql"
    "github.com/jinzhu/gorm"
)

type Database struct {
    *gorm.DB
}

func (db *Database) openDB() {
    dsn := "username:password@tcp(127.0.0.1:3306)/godb?charset=utf8&parseTime=True"
    conn, err := sql.Open("mysql", dsn)
    if err != nil {
        log.Fatal(err)
    }

    db.DB = gorm.Open("mysql", conn)
}

Kami kini perlu mencipta objek Pangkalan Data baharu dalam fungsi utama dan membuka sambungan menggunakan fungsi openDB.

db := new(Database)
db.openDB()

Seterusnya, kami akan mencipta Model Tugasan untuk dikaitkan dengan senarai tugas kami. Model hanyalah struct Go biasa yang akan dipetakan ke jadual dalam pangkalan data MySQL kami.

type Task struct {
    Id      int    `gorm:"primary_key;auto_increment"`
    Name    string `gorm:"not null"`
    Content string `gorm:"not null"`
}

Untuk mencipta tugasan baharu, kami akan mencipta fungsi pengendali yang dipanggil "createTask". Fungsi ini akan menerima data JSON daripada permintaan HTTP, menghuraikannya dan memasukkannya ke dalam pangkalan data kami.

func createTask(w http.ResponseWriter, r *http.Request) {
    db := new(Database)
    db.openDB()

    task := &Task{}
    task.Name = r.FormValue("name")
    task.Content = r.FormValue("content")

    db.Create(&task)
    fmt.Fprintln(w, "Task successfully created")
}

Kami melihat bahawa fungsi "createTask" mencipta objek Pangkalan Data baharu dan objek Tugas pada mulanya. Ia kemudian menghuraikan data JSON daripada permintaan HTTP dan memasukkannya ke dalam pangkalan data dengan memanggil kaedah db.Create().

Akhir sekali, kami akan mengemas kini laluan "router.HandleFunc" kami untuk memasukkan laluan baharu.

router.HandleFunc("/tasks", createTask).Methods("POST")

5. Middleware

Middleware ialah teknologi biasa yang digunakan untuk melaksanakan operasi sebelum atau selepas memproses permintaan. Mereka bukan sahaja digunakan secara meluas di Golang tetapi juga biasa dalam bahasa lain. Mari lihat cara menggunakan perisian tengah untuk menambah beberapa fungsi tambahan dalam API Golang.

Di Golang, middleware ialah fungsi yang mengambil fungsi pemprosesan HTTP sebagai parameter. Mereka membenarkan beberapa logik untuk dilaksanakan sebelum atau selepas permintaan diproses. Dalam contoh berikut, kami akan mencipta perisian tengah yang dipanggil "withLogging" yang akan log butiran semua permintaan API.

func withLogging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println(r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

Kami melihat bahawa fungsi http.Handler baharu dikembalikan dalam fungsi, yang merekodkan kaedah yang diminta dan laluan URL. Pernyataan seterusnya.ServeHTTP(w, r) memanggil pengendali seterusnya, memastikan pengendali terus memproses permintaan API.

Seterusnya, kami akan mengemas kini laluan dan pengendali kami untuk memasukkan perisian tengah pengelogan baharu.

router := mux.NewRouter()

router.Use(withLogging)

router.HandleFunc("/", Index)
router.HandleFunc("/tasks", createTask).Methods("POST")
router.HandleFunc("/tasks", getTasks).Methods("GET")

Sekarang, tambahkan pernyataan "router.Use(withLogging)" sebelum laluan dan kami akan melaksanakan middleware withLogging pada semua permintaan penghalaan.

6. Ringkasan

Dalam artikel ini, kami memperkenalkan cara menggunakan gorila/mux untuk mengendalikan penghalaan di Golang, menggunakan gorm untuk mengurus pangkalan data MySQL dan cara menggunakan perisian tengah untuk meningkatkan API kami. Dengan memahami konsep dan kemahiran asas ini, kita boleh mula membina API Golang yang lebih kompleks.

Atas ialah kandungan terperinci golang api build. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!