Golang adalah salah satu bahasa pemrograman yang paling banyak diminati dengan banyak aplikasi. Saat dipasangkan dengan kerangka kerja seperti Gin, Revel, dan gorila/mux, Anda dapat dengan mudah membuat API dengan Go.

Pelajari cara membuat CRUD API di Golang menggunakan kerangka kerja HTTP Gin.

Pengaturan dan Instalasi Awal

Mulailah dengan Golang dengan menginstalnya di komputer Anda jika Anda belum melakukannya.

Setelah terinstal, langkah selanjutnya adalah membuat folder root proyek di mesin Anda dan menginisialisasi modul Go di direktori root tersebut.

Untuk melakukan ini, buka sebuah CLI, navigasikan ke folder root proyek Anda dan jalankan:

pergi mod init module_name

Anda akan melihat nama modul Anda (mis. CRUD_API) dan versinya saat Anda membuka go.mod mengajukan. Semua paket khusus akan berasal dari modul induk ini. Jadi setiap paket kustom yang diimpor berbentuk:

impor(kemasan CRUD_API/kemasan-nama-direktori)

Selanjutnya, instal paket yang diperlukan untuk membuat CRUD API. Dalam hal ini, gunakan Gin Gonic untuk merutekan titik akhir API:

instagram viewer 
Pergilah Dapatkan github.com/gin-gonic/gin

Sekarang instal Driver MongoDB untuk menyimpan data:

Pergilah Dapatkan go.mongodb.org/mongo-driver/mongo

Bagaimana Menghubungkan Pergi ke MongoDB

Yang Anda butuhkan hanyalah URI MongoDB Anda untuk menghubungkan Golang dengan database. Biasanya terlihat seperti ini jika Anda terhubung ke MongoDB Atlas secara lokal:

Mongo_URL = "mongodb://127.0.0.1:27017"

Sekarang buat folder baru di direktori root proyek Anda dan beri nama database. Buat file Go di dalam folder ini dan beri nama database.go.

Ini adalah paket database Anda, dan ini dimulai dengan mengimpor perpustakaan yang diperlukan:

kemasan basis data
impor (
"konteks"
"fmt"
"catatan"
"waktu"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)


fungsi ConnectDB() *mongo. Klien {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	klien, err := mongo. Klien Baru (opsi. Klien().TerapkanURI(Mongo_URL))


jika salah != nihil {
catatan.Fatal(berbuat salah)
	}


ctx, batalkan := konteks. Tanpa Waktu Habis (context. Latar Belakang(), 10 * waktu. Kedua)
	salah = klien. Hubungkan (ctx)
	tunda batal()


jika salah != nihil {
catatan.Fatal(berbuat salah)
	}
fmt. Cetak("Terhubung ke mongoDB")
kembali klien
}

Praktik terbaik untuk menyembunyikan variabel lingkungan seperti string koneksi database di a .env mengajukan menggunakan paket dotenv. Ini membuat kode Anda lebih portabel dan berguna saat menggunakan a Contoh kluster awan MongoDB, Misalnya.

Itu ConnectDB fungsi membuat koneksi dan mengembalikan objek Klien MongoDB baru.

Buat Koleksi Basis Data

MongoDB menyimpan data dalam Koleksi, yang menyediakan antarmuka ke data basis data yang mendasarinya.

Untuk menangani fungsionalitas pengambilan koleksi, mulailah dengan membuat folder baru, Koleksi, di root proyek Anda. Sekarang buat file Go baru, getCollection.go, yang mendapatkan koleksi dari database:

kemasan dapatkan koleksi
impor (
"go.mongodb.org/mongo-driver/mongo"
)
fungsiDapatkan Koleksi(klien *mongo.Klien, nama koleksirangkaian) *mongo.Koleksi {
	koleksi := klien. Basis Data ("myGoappDB").Koleksi("Postingan")
kembali koleksi
}

Fungsi ini mendapatkan Koleksi dari database MongoDB. Nama database, dalam hal ini, adalah myGoappDB, dengan Postingan sebagai koleksinya.

Buat Model Basis Data

Buat folder baru di dalam direktori root Anda dan beri nama model. Folder ini menangani model database Anda.

Buat file Go baru di dalam folder itu dan beri nama model.go. Model Anda, dalam hal ini, adalah posting blog dengan judulnya:

kemasan model
impor (
"go.mongodb.org/mongo-driver/bson/primitif"
)
Tipe Struktur posting {
PENGENALprimitif.IDObjek
	String judul
	String artikel
}

Membuat CRUD API Dengan Go

Selanjutnya adalah pembuatan CRUD API. Untuk memulai dengan bagian ini, buat folder baru di dalam direktori root proyek Anda untuk menangani titik akhir Anda. Sebut saja rute.

Buat file Go terpisah di folder ini untuk setiap tindakan. Misalnya, Anda dapat menamainya create.go, baca.go, update.go, dan hapus.go. Anda akan mengekspor penangan ini sebagai rute kemasan.

Cara Membuat Titik Akhir POST di Go

Mulailah dengan mendefinisikan titik akhir POST untuk menulis data ke dalam database.

Dalam route/create.go, tambahkan berikut ini:

kemasan rute
impor (
	dapatkan koleksi "CRUD_API/Koleksi"
	basis data "CRUD_API/database"
	model "CRUD_API/model"
"konteks"
"catatan"
"bersih/http"
"waktu"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitif"
)


fungsi Buat Posting(c *gin. Konteks){
var DB = basis data. HubungkanDB()
	var postCollection = getcollection. Dapatkan Koleksi (DB, "Postingan")
	ctx, batalkan := konteks. Tanpa Waktu Habis (context. Latar Belakang(), 10*waktu. Kedua)
	posting := baru(model. Postingan)
	tunda batal()


jika salah := c. BindJSON(&pos); salah != nihil {
 c. JSON(http. StatusBadRequest, gin. H{"pesan": salah})
catatan.Fatal(berbuat salah)
kembali
	}


postPayload := model. Posting{
Indo: primitif.NewObjectID(),
Judul: pos.Judul,
Artikel: pos.Artikel,
	}


hasil, err := postCollection. InsertOne (ctx, postPayload)


jika salah != nihil {
 c. JSON(http. StatusInternalServerError, gin. H{"pesan": salah})
kembali
	}
c. JSON(http. StatusDibuat, gin. H{"pesan": "Diposting dengan sukses", "Data": peta[string]antarmuka{}{"data": hasil}})
}

Kode ini dimulai dengan mengimpor modul kustom proyek. Itu kemudian mengimpor paket pihak ketiga termasuk Gin dan Driver MongoDB.

Lebih jauh, pascaKoleksi menyimpan koleksi database. Terutama, c. BindJSON("posting") adalah contoh model JSONified yang memanggil setiap bidang model sebagai pascaPayload; ini masuk ke database.

Cara Membuat Titik Akhir GET

Titik akhir GET, dalam rute/baca.go, membaca satu dokumen dari database melalui ID uniknya. Itu juga dimulai dengan mengimpor paket khusus dan pihak ketiga:

kemasan rute
impor (
	dapatkan koleksi "CRUD_API/Koleksi"
	basis data "CRUD_API/database"
	model "CRUD_API/model"
"konteks"
"bersih/http"
"waktu"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitif"
)


fungsi BacaSatuPost(c *gin. Konteks){
	ctx, batalkan := konteks. Tanpa Waktu Habis (context. Latar Belakang(), 10*waktu. Kedua)
var DB = basis data. HubungkanDB()
	var postCollection = getcollection. Dapatkan Koleksi (DB, "Postingan")


postId := c. Param("postId")
var model hasil. Postingan


tunda batal()


objId, _ := primitif. ObjectIDFromHex (postId)


err := postCollection. Temukan Satu (ctx, bson. M{"Indo": objId}).Decode(&hasil)


res := peta[string]antarmuka{}"data": hasil}


jika salah != nihil {
 c. JSON(http. StatusInternalServerError, gin. H{"pesan": salah})
kembali
	}
c. JSON(http. StatusDibuat, gin. H{"pesan": "kesuksesan!", "Data": res})
}

Itu postId variabel adalah deklarasi parameter. Itu mendapat ID objek dokumen sebagai objId.

Namun, hasil adalah turunan dari model database, yang kemudian menyimpan dokumen yang dikembalikan sebagai res.

Cara Membuat Titik Akhir PUT

Pengendali PUT, di route/update.go, mirip dengan penangan POST. Kali ini, ia memperbarui posting yang ada dengan ID objek uniknya:

kemasan rute
impor (
	dapatkan koleksi "CRUD_API/Koleksi"
	basis data "CRUD_API/database"
	model "CRUD_API/model"
"konteks"
"bersih/http"
"waktu"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitif"
)


fungsi Perbarui Posting(c *gin. Konteks){
	ctx, batalkan := konteks. Tanpa Waktu Habis (context. Latar Belakang(), 10 * waktu. Kedua)
var DB = basis data. HubungkanDB()
	var postCollection = getcollection. Dapatkan Koleksi (DB, "Postingan")


postId := c. Param("postId")
var model pos. Postingan


tunda batal()


objId, _ := primitif. ObjectIDFromHex (postId)


jika salah := c. BindJSON(&pos); salah != nihil {
 c. JSON(http. StatusInternalServerError, gin. H{"pesan": salah})
kembali
	}


diedit := bson. M{"judul": pos. Judul, "artikel": pos. Artikel}


hasil, err := postCollection. PerbaruiSatu (ctx, bson. M{"Indo": objId}, bson. M{"$set": diedit})


res := peta[string]antarmuka{}"data": hasil}


jika salah != nihil {
 c. JSON(http. StatusInternalServerError, gin. H{"pesan": salah})
kembali
	}


jika hasil. Jumlah yang cocok < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"pesan": "Data tidak'tidak ada"})
kembali
	}
c. JSON(http. StatusDibuat, gin. H{"pesan": "data berhasil diperbarui!", "Data": res})
}

Format JSON dari contoh model (pos) memanggil setiap bidang model dari database. Variabel hasil menggunakan MongoDB $set operator untuk memperbarui dokumen yang diperlukan yang dipanggil oleh ID objeknya.

Itu hasil. Jumlah yang cocok kondisi mencegah kode berjalan jika tidak ada catatan dalam database atau ID yang diteruskan tidak valid.

Membuat Titik Akhir DELETE

Titik akhir DELETE, dalam hapus.go, menghapus dokumen berdasarkan ID objek yang diteruskan sebagai parameter URL:

kemasan rute
impor (
	dapatkan koleksi "CRUD_API/Koleksi"
	basis data "CRUD_API/database"
"konteks"
"bersih/http"
"waktu"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitif"
)


fungsi Hapus Posting(c *gin. Konteks){
	ctx, batalkan := konteks. Tanpa Waktu Habis (context. Latar Belakang(), 10*waktu. Kedua)
var DB = basis data. HubungkanDB()
	postId := c. Param("postId")


var postCollection = getcollection. Dapatkan Koleksi (DB, "Postingan") 
	tunda batal()
	objId, _ := primitif. ObjectIDFromHex (postId) 
	hasil, err := postCollection. HapusSatu (ctx, bson. M{"Indo": objId}) 
	res := peta[string]antarmuka{}"data": hasil}


jika salah != nihil {
 c. JSON(http. StatusInternalServerError, gin. H{"pesan": salah})
kembali
	}


jika hasil. Dihapus Hitung < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"pesan": "Tidak ada data untuk dihapus"})
kembali
	}
c. JSON(http. StatusDibuat, gin. H{"pesan": "Artikel berhasil dihapus", "Data": res})
}

Kode ini menghapus catatan menggunakan HapusSatu fungsi. Ini juga menggunakan hasil. Dihapus Hitung properti untuk mencegah kode berjalan jika database kosong atau ID objek tidak valid.

Buat File Pelari API

Terakhir, buat main.go di dalam direktori root proyek Anda. Struktur proyek akhir Anda akan terlihat seperti ini:

File ini menangani eksekusi router untuk setiap titik akhir:

kemasan utama
impor (
 rute "CRUD_API/rute"
"github.com/gin-gonic/gin"
)


fungsi utama(){
 router := gin.Bawaan()


router. POS("/", rute. Buat Posting)


// dipanggil sebagai localhost: 3000/getOne/{id}
 router. DAPATKAN("getOne/:postId", rute. BacaSatuPost)


// dipanggil sebagai localhost: 3000/memperbarui/{Indo}
 router. TARUH("/update/:postId", rute. Perbarui Posting)


// dipanggil sebagai localhost: 3000/menghapus/{Indo}
 router. MENGHAPUS("/menghapus/:postId", rute. Hapus Posting)
router. Lari("host lokal: 3000")
}

File ini adalah paket utama yang menjalankan file lain. Ini dimulai dengan mengimpor penangan rute. Berikutnya adalah router variabel, gin contoh yang membangkitkan tindakan HTTP dan memanggil setiap titik akhir dengan nama fungsinya dari rute kemasan.

Proyek CRUD Anda berjalan terus host lokal: 3000. Untuk menjalankan server dan menguji CRUD API, jalankan perintah berikut di direktori dasar Anda:

PergilahLariutama.Pergilah

Ubah Proyek CRUD Golang Anda Menjadi Produk yang Dapat Digunakan

Anda telah berhasil membuat CRUD API dengan Go; Selamat! Meskipun ini adalah proyek kecil, Anda telah melihat apa yang diperlukan untuk mengeksekusi permintaan HTTP reguler di Go.

Anda bisa menjadi lebih kreatif dengan mengembangkannya menjadi aplikasi yang lebih praktis yang memberikan nilai bagi pengguna. Go adalah bahasa pemrograman yang cocok untuk berbagai kasus penggunaan.