Bagaimanakah API RESTful dilaksanakan dalam bahasa Go?

Dengan pembangunan Internet dan aplikasi mudah alih, RESTful API telah menjadi gaya reka bentuk antara muka yang popular. Oleh kerana ia mudah, berskala dan cekap, semakin banyak syarikat dan pembangun memilih API RESTful sebagai antara muka untuk aplikasi mereka. Dalam bahasa Go, adalah perkara biasa untuk melaksanakan API RESTful. Artikel ini akan memperkenalkan pelaksanaan RESTful API dalam bahasa Go dan beberapa amalan terbaik.

1. Apakah itu RESTful API?

RESTful API ialah antara muka perkhidmatan web berdasarkan seni bina REST (Representational State Transfer). Ia menggunakan protokol HTTP untuk komunikasi dan melaksanakan operasi CRUD (buat, baca, kemas kini, padam) pada sumber pelayan melalui pelbagai kaedah HTTP. Kaedah HTTP ini termasuk GET, POST, PUT, DELETE, dll. RESTful API menekankan pengenalpastian sumber dan penukaran keadaan Setiap sumber mempunyai URI (Uniform Resource Identifier) ​​​​untuk mengenal pasti sumber dan menggunakan kaedah HTTP untuk menukar keadaannya.

2. Langkah asas untuk melaksanakan API RESTful dalam bahasa Go

1 Pasang pustaka yang diperlukan

Melaksanakan API RESTful dalam bahasa Go memerlukan penggunaan beberapa pakej biasa, seperti. sebagai net/http, pengekodan/json, dsb. Memasang perpustakaan ini sangat mudah, cuma jalankan arahan berikut dalam terminal:

go get -u github.com/gorilla/mux
go get -u github.com/rs/cors

Antaranya, perpustakaan gorila/mux ialah salah satu penghala permintaan HTTP paling popular dalam bahasa Go, yang menyediakan penghalaan HTTP yang berkuasa fungsi. Pustaka rs/cors membolehkan anda mengendalikan perkongsian sumber silang asal (CORS) dengan mudah.

2. Cipta laluan API RESTful

Dalam bahasa Go, kita boleh menggunakan pakej mux untuk mencipta laluan API RESTful. Pertama, kita perlu mengimport pakej mux dan kemudian menentukan penghala baharu. Seterusnya, kita boleh menggunakan kaedah HandleFunc penghala untuk memetakan kaedah HTTP yang berbeza dan laluan penghalaan ke fungsi pengendali. Sebagai contoh, berikut ialah contoh mudah untuk melaksanakan API RESTful:

package main

import (
 "encoding/json"
 "log"
 "net/http"
 "github.com/gorilla/mux"
 "github.com/rs/cors"
)

type Book struct {
 ID    string  `json:"id"`
 Title string  `json:"title"`
}

var books []Book

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

 // Get all books
 router.HandleFunc("/books", getBooks).Methods("GET")

 // Get a book by ID
 router.HandleFunc("/books/{id}", getBook).Methods("GET")

 // Add a book
 router.HandleFunc("/books", addBook).Methods("POST")

 // Update a book
 router.HandleFunc("/books/{id}", updateBook).Methods("PUT")

 // Delete a book
 router.HandleFunc("/books/{id}", deleteBook).Methods("DELETE")

 handler := cors.Default().Handler(router)

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

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

func getBook(w http.ResponseWriter, r *http.Request) {
 params := mux.Vars(r)
 for _, item := range books {
  if item.ID == params["id"] {
   json.NewEncoder(w).Encode(item)
   return
  }
 }
 json.NewEncoder(w).Encode(&Book{})
}

func addBook(w http.ResponseWriter, r *http.Request) {
 var book Book
 _ = json.NewDecoder(r.Body).Decode(&book)
 books = append(books, book)
 json.NewEncoder(w).Encode(book)
}

func updateBook(w http.ResponseWriter, r *http.Request) {
 params := mux.Vars(r)
 for index, item := range books {
  if item.ID == params["id"] {
   books[index].Title = params["title"]
   json.NewEncoder(w).Encode(books[index])
   return
  }
 }
 json.NewEncoder(w).Encode(books)
}

func deleteBook(w http.ResponseWriter, r *http.Request) {
 params := mux.Vars(r)
 for index, item := range books {
  if item.ID == params["id"] {
   books = append(books[:index], books[index+1:]...)
   break
  }
 }
 json.NewEncoder(w).Encode(books)
}

Dalam kod di atas, kami mentakrifkan struktur Buku dan tatasusunan buku. Kami menggunakan mux.NewRouter() untuk mencipta penghala baharu dan menggunakan kaedah penghala.HandleFunc() untuk memetakan kaedah HTTP dan laluan penghalaan ke fungsi pengendali API RESTful. Sebagai contoh, fungsi getBooks() mengendalikan permintaan GET /books dan mengekod tatasusunan buku melalui json.NewEncoder() dan menulisnya ke ResponseWriter.

Dalam fungsi main(), kami juga menggunakan kaedah cors.Default().Handler() untuk mencipta pengendali CORS baharu dan menggunakan kaedah http.ListenAndServe() untuk memulakan perkhidmatan API RESTful dan dengar pada port lalai 8080.

3. Gunakan corak objek pemindahan (DTO)

Dalam reka bentuk RESTful API, kita perlu mentakrifkan objek pemindahan (DTO), iaitu struktur data ringkas yang digunakan pada klien Pindahkan data ke dan dari pelayan. Dalam bahasa Go, kita boleh menggunakan struktur (struct) sebagai DTO. Setiap struktur mewakili jenis data dan mengandungi medan untuk dihantar kepada klien. Sebagai contoh, kod berikut mentakrifkan struktur Pengguna:

type User struct {
 ID       int    `json:"id"`
 Name     string `json:"name"`
 Email    string `json:"email"`
 Password string `json:"-"`
}

Dalam kod di atas, kami mentakrifkan struktur Pengguna, yang mengandungi medan ID, Nama, E-mel dan Kata Laluan. Kami menggunakan tag json untuk menukar medan struktur ke dalam format JSON. Ambil perhatian bahawa kami menggunakan bendera "-" untuk mengabaikan medan Kata Laluan dan mengelak daripada menghantar kata laluan dalam teks yang jelas kepada klien.

4. Gunakan HTTPS untuk melindungi API RESTful

Memandangkan API RESTful berkomunikasi melalui protokol HTTP, keselamatannya mungkin terjejas. Untuk memastikan keselamatan API RESTful, kami boleh menggunakan protokol HTTPS (HTTP Secure) untuk melindungi kandungan komunikasi. Protokol HTTPS menggunakan teknologi penyulitan SSL (Secure Socket Layer) atau TLS (Transport Layer Security) untuk memastikan keselamatan permintaan dan respons HTTP.

Dalam bahasa Go, kami boleh menggunakan pakej net/http dan pakej crypto/tls untuk menyokong HTTPS. Sebagai contoh, kod berikut menunjukkan cara membuat pelayan HTTPS dengan sijil yang ditandatangani sendiri:

package main

import (
 "log"
 "net/http"
 "crypto/tls"
)

func main() {
 mux := http.NewServeMux()

 // Define HTTP routes

 // Create self-signed certificate
 cert, err := tls.LoadX509KeyPair("cert.pem", "key.pem")
 if err != nil {
  log.Fatal(err)
 }

 // Create HTTPS server
 server := &http.Server{
  Addr: ":8443",
  TLSConfig: &tls.Config{
   Certificates: []tls.Certificate{cert},
  },
 }

 // Start HTTPS server
 log.Fatal(server.ListenAndServeTLS("", ""))
}

Dalam kod di atas, kami mencipta penghala HTTP baharu menggunakan http.NewServeMux() dan kemudian menggunakan tls.LoadX509KeyPair () Muatkan sijil yang ditandatangani sendiri. Akhir sekali, kami memulakan pelayan HTTPS menggunakan kaedah http.Server.ListenAndServeTLS() dan lulus konfigurasi sijil kepada TLSConfig.

5. Gunakan JWT untuk melindungi API RESTful

Apabila membangunkan API RESTful, kami juga perlu melindungi API untuk memastikan hanya pengguna yang dibenarkan boleh mengaksesnya. Pendekatan biasa ialah menggunakan JWT (JSON Web Token) untuk pengesahan dan kebenaran.

Dalam bahasa Go, kami boleh menggunakan pakej jwt-go untuk menjana dan mengesahkan JWT. Sebagai contoh, kod berikut menunjukkan cara membuat dan mengesahkan JWT menggunakan pakej jwt-go:

package main

import (
 "fmt"
 "time"
 "github.com/dgrijalva/jwt-go"
)

func main() {
 // Define a claim
 claim := jwt.MapClaims{
  "user_id": 1234,
  "iss": "myapp",
  "exp": time.Now().Add(time.Hour * 24).Unix(),
 }

 // Create a new JWT
 token := jwt.NewWithClaims(jwt.SigningMethodHS256, claim)

 // Sign the JWT using a secret key
 secret := []byte("mysecret")
 signedToken, err := token.SignedString(secret)
 if err != nil {
  fmt.Println(err)
 }

 fmt.Println("JWT:", signedToken)

 // Verify the JWT
 token, err = jwt.Parse(signedToken, func(token *jwt.Token) (interface{}, error) {
  if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
   return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
  }

  return secret, nil
 })

 if err != nil {
  fmt.Println(err)
 }

 if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
  fmt.Println("JWT claims:", claims)
 } else {
  fmt.Println("Invalid JWT")
 }
}

Dalam kod di atas, kami telah menentukan pembolehubah MapClaims sebagai pengisytiharan. Ini sepadan dengan muatan JSON JWT, yang boleh mengandungi pasangan nilai kunci sewenang-wenangnya. Kami menetapkan masa tamat tempoh JWT kepada 24 jam. Kami kemudian mencipta JWT baharu menggunakan kaedah jwt.NewWithClaims() dan menentukan algoritma tandatangan menggunakan jwt.SigningMethodHS256. Seterusnya, kami menandatangani JWT dengan kunci rahsia menggunakan kaedah jwt.Token.SignedString().

Apabila mengesahkan JWT, kami menggunakan kaedah jwt.Parse() untuk menghuraikan JWT dan menentukan fungsi panggil balik untuk mengesahkan tandatangan JWT. Fungsi panggil balik mesti mengembalikan nilai antara muka jenis{} yang mewakili kunci yang digunakan untuk menandatangani JWT. Dalam kod di atas, kami menggunakan kunci berkod keras, tetapi biasanya kami menyimpan kunci di lokasi yang selamat dan menetapkannya melalui pembolehubah persekitaran atau fail konfigurasi.

6. Kesimpulan

Dalam artikel ini, kami memperkenalkan langkah asas untuk melaksanakan API RESTful dalam bahasa Go. Kami menggunakan pakej mux untuk mencipta penghala dan memetakan kaedah HTTP dan laluan penghalaan kepada pengendali API RESTful. Kami juga meliputi langkah keselamatan seperti JWT dan HTTPS untuk melindungi API RESTful. Akhir sekali, kami juga menyerlahkan kepentingan menggunakan corak objek pengangkutan untuk memudahkan reka bentuk dan pelaksanaan API RESTful.

Atas ialah kandungan terperinci Bagaimanakah API RESTful dilaksanakan dalam bahasa Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!