Golang melaksanakan rehat

Golang ialah bahasa pengaturcaraan yang cekap, pantas, selamat dan boleh dipercayai. Sintaksnya yang ringan, keupayaan pengaturcaraan serentak dan perpustakaan API yang kaya menjadikannya bahasa yang ideal untuk membina aplikasi berprestasi tinggi dan ketersediaan tinggi. Dalam artikel ini, kami akan memperkenalkan cara menggunakan Golang untuk melaksanakan API RESTful.

Apakah itu RESTful API?

REST (Pemindahan Negeri Perwakilan) ialah gaya seni bina dan corak reka bentuk untuk API Web. RESTful API ialah API yang berkomunikasi dengan pelanggan menggunakan protokol HTTP. Ia membenarkan penggunaan kata kerja HTTP (GET, POST, PUT, DELETE, dll.) untuk melaksanakan operasi (baca, cipta, kemas kini dan padam sumber) pada pelayan. API RESTful direka untuk kebolehskalaan, kebolehlanjutan dan kebolehgunaan semula.

Gunakan Golang untuk melaksanakan API RESTful

Di bawah kami akan menggunakan Golang untuk melaksanakan API RESTful yang mudah. API ini akan menggunakan Gorilla Mux dan Gorm untuk mengendalikan penghalaan dan pangkalan data. Gorilla Mux ialah penghala dan penjadual HTTP yang berkuasa, dan Gorm ialah perpustakaan ORM yang pantas dan ringkas.

Pertama, kita perlu memasang perpustakaan ini. Saya menggunakan mod go untuk menguruskan kebergantungan. Dalam direktori akar projek, buka terminal dan masukkan arahan berikut:

go mod init example.com/restful-api
go get github.com/gorilla/mux
go get github.com/jinzhu/gorm
go get github.com/go-sql-driver/mysql

Sekarang, kita boleh mula menulis kod. Kita perlu mencipta fail berikut:

• main.go
• models/user.go
• pengendali/user.go

1. main.go

main.go ialah fail penyertaan kami. Kami akan mendaftarkan laluan dan memulakan pelayan dalam fail ini. Berikut ialah kod:

package main

import (
    "log"
    "net/http"

    "example.com/restful-api/handlers"
    "github.com/gorilla/mux"
)

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

    r.HandleFunc("/users", handlers.GetUsers).Methods("GET")
    r.HandleFunc("/users", handlers.CreateUser).Methods("POST")
    r.HandleFunc("/users/{id}", handlers.GetUser).Methods("GET")
    r.HandleFunc("/users/{id}", handlers.UpdateUser).Methods("PUT")
    r.HandleFunc("/users/{id}", handlers.DeleteUser).Methods("DELETE")

    log.Fatal(http.ListenAndServe(":8080", r))
}

Dalam kod ini, kami menggunakan mux.NewRouter() untuk mencipta penghala baharu dan mendaftarkan fungsi pengendali untuk setiap kaedah HTTP (GET, POST, PUT dan DELETE).

2. models/user.go

Seterusnya, kami akan menentukan model data pengguna kami. Kami akan menulisnya dalam models/user.go. Berikut ialah kod:

package models

import "github.com/jinzhu/gorm"

type User struct {
    gorm.Model
    Name  string `gorm:"not null"`
    Email string `gorm:"not null;unique_index"`
    Age   int    `gorm:"not null"`
}

Dalam model ini, kami menggunakan struktur Model Gorm. Ia mengandungi medan rekod pangkalan data biasa seperti medan ID, CreatedAt dan UpdatedAt. Kami telah menentukan medan Nama, E-mel dan Umur yang akan disimpan dalam pangkalan data.

3. pengendali/pengguna.go

Akhir sekali, kami akan menulis fungsi pengendali kami. Kami akan menulisnya dalam handlers/user.go. Berikut ialah kodnya:

package handlers

import (
    "encoding/json"
    "fmt"
    "net/http"
    "strconv"

    "example.com/restful-api/models"
    "github.com/gorilla/mux"
    "github.com/jinzhu/gorm"
)

var db *gorm.DB

func init() {
    var err error
    db, err = gorm.Open("mysql", "{username}:{password}@tcp({host}:{port})/{database}")
    if err != nil {
        panic("failed to connect database")
    }
    db.AutoMigrate(&models.User{})
}

func GetUsers(w http.ResponseWriter, r *http.Request) {
    var users []models.User
    db.Find(&users)
    json.NewEncoder(w).Encode(users)
}

func GetUser(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    id, _ := strconv.Atoi(params["id"])
    var user models.User
    db.First(&user, id)
    json.NewEncoder(w).Encode(user)
}

func CreateUser(w http.ResponseWriter, r *http.Request) {
    var user models.User
    json.NewDecoder(r.Body).Decode(&user)
    db.Create(&user)
    json.NewEncoder(w).Encode(user)
}

func UpdateUser(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    id, _ := strconv.Atoi(params["id"])
    var user models.User
    db.First(&user, id)
    json.NewDecoder(r.Body).Decode(&user)
    db.Save(&user)
    json.NewEncoder(w).Encode(user)
}

func DeleteUser(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    id, _ := strconv.Atoi(params["id"])
    var user models.User
    db.Delete(&user, id)
    fmt.Fprintf(w, "User #%d deleted successfully", id)
}

Kami mula-mula menggunakan kaedah gorm.Open() Gorm untuk menyambung ke pangkalan data dan memindahkan model pengguna kami secara automatik. Seterusnya, kami menulis lima fungsi pemproses: GetUsers(), GetUser(), CreateUser(), UpdateUser() dan DeleteUser(). Fungsi

GetUsers() mengambil semua pengguna daripada pangkalan data dan menghantarnya kembali kepada klien sebagai respons JSON. Fungsi

GetUser() menggunakan ID dalam parameter URL untuk mencari dan mengembalikan maklumat pengguna individu. Kami menggunakan kaedah mux.Vars() untuk mengekstrak ID daripada permintaan. Fungsi

CreateUser() membaca data JSON daripada badan permintaan dan menyimpan maklumat pengguna ke dalam pangkalan data. Fungsi

UpdateUser() membaca data JSON daripada permintaan dan mengemas kini maklumat pengguna yang sepadan menggunakan ID dalam parameter URL. Fungsi

DeleteUser() menggunakan ID dalam parameter URL untuk memadamkan pengguna yang sepadan daripada pangkalan data.

Kini kami telah melengkapkan semua komponen API RESTful kami. Kami boleh menguji API pada port tempatan menggunakan alat seperti Posman atau curl.

Ringkasan

Golang ialah bahasa yang berkuasa dan mudah digunakan Ia sangat mudah, pantas dan cekap untuk melaksanakan API RESTful menggunakan Golang. Kami boleh menggunakan Gorilla Mux dan Gorm untuk mengendalikan penghalaan dan operasi pangkalan data. Dalam artikel ini, kami menunjukkan cara membuat API RESTful menggunakan Golang, berdasarkan contoh mudah. Melalui artikel ini, pembaca boleh memahami dan mempelajari cara menggunakan Golang untuk membina API RESTful dengan cepat.

Atas ialah kandungan terperinci Golang melaksanakan rehat. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!