Kā izveidot CRUD API, izmantojot Golang's Gin un MongoDB

Golang ir viena no vislabāk apmaksātajām, pieprasītajām programmēšanas valodām ar daudzām lietojumprogrammām. Savienojot pārī ar tādiem ietvariem kā Gin, Revel un gorilla/mux, varat viegli izveidot API, izmantojot Go.

Uzziniet, kā izveidot CRUD API Golangā, izmantojot Gin HTTP ietvaru.

---

---

DIENAS VIDEO MAKEUSEOF

Sākotnējā iestatīšana un instalēšana

Sāciet darbu ar Golangu instalējot to savā datorā, ja vēl neesat to izdarījis.

Vai es varu izmantot divu dažādu zīmolu aunus?

Pēc instalēšanas nākamais solis ir izveidot projekta saknes mapi savā datorā un inicializēt Go moduli šajā saknes direktorijā.

Lai to izdarītu, atveriet CLI , dodieties uz sava projekta saknes mapi un palaidiet:

go mod init module_name 

Jūs redzēsit sava moduļa nosaukumu (piem., CRUD_API ) un tā versiju, atverot go.mod failu. Visas pielāgotās pakotnes nāks no šī vecākmoduļa. Tātad jebkurai importētajai pielāgotajai pakotnei ir šāda forma:

import(package CRUD_API/package-directory-name)

Pēc tam instalējiet pakotnes, kas nepieciešamas CRUD API izveidei. Šajā gadījumā izmantojiet Džins Goniks lai maršrutētu API galapunktus:

---

---

go get github.com/gin-gonic/gin 

Tagad instalējiet MongoDB draiveri, lai saglabātu datus:

go get go.mongodb.org/mongo-driver/mongo

Kā izveidot savienojumu Dodieties uz MongoDB

Viss, kas jums nepieciešams, ir jūsu MongoDB URI, lai savienotu Golang ar datu bāzi. Parasti tas izskatās šādi, ja vietēji veidojat savienojumu ar MongoDB Atlas:

---

---

Mongo_URL = "mongodb://127.0.0.1:27017"

Tagad izveidojiet jaunu mapi sava projekta saknes direktorijā un izsauciet to datubāzēm . Izveidojiet Go failu šajā mapē un nosauciet to datubāze.go .

Šī ir jūsu datu bāzes pakotne, un tā sākas, importējot nepieciešamās bibliotēkas:

package database 
  
import ( 
	"context" 
	"fmt" 
	"log" 
	"time" 
	"go.mongodb.org/mongo-driver/mongo" 
	"go.mongodb.org/mongo-driver/mongo/options" 
) 
  
func ConnectDB() *mongo.Client { 
	Mongo_URL := "mongodb://127.0.0.1:27017" 
	client, err := mongo.NewClient(options.Client().ApplyURI(Mongo_URL)) 
  
	if err != nil { 
		log.Fatal(err) 
	} 
  
	ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second) 
	err = client.Connect(ctx) 
	defer cancel() 
  
	if err != nil { 
		log.Fatal(err) 
	} 
  
	fmt.Println("Connected to mongoDB") 
	return client 
} 

Labākā prakse ir paslēpt vides mainīgos, piemēram, datubāzes savienojuma virkni a .env failu izmantojot dotenv pakotni . Tas padara jūsu kodu pārnēsājamāku un noderēs, izmantojot a MongoDB mākoņu klastera gadījums , piemēram.

The ConnectDB funkcija izveido savienojumu un atgriež jaunu MongoDB klienta objektu.

Izveidot datu bāzes kolekciju

MongoDB glabā datus kolekcijās, kas nodrošina saskarni ar pamatā esošajiem datu bāzes datiem.

Lai apstrādātu kolekcijas ielādes funkcionalitāti, vispirms izveidojiet jaunu mapi, Kolekcija , jūsu projekta saknē. Tagad izveidojiet jaunu Go failu, getCollection.go , kas iegūst kolekciju no datu bāzes:

atšķirība starp samsung pay un android pay

package getcollection 
  
import ( 
	"go.mongodb.org/mongo-driver/mongo" 
) 
  
func GetCollection(client *mongo.Client, collectionName string) *mongo.Collection { 
	collection := client.Database("myGoappDB").Collection("Posts") 
	return collection 
} 

Šī funkcija iegūst kolekciju no MongoDB datu bāzes. Šajā gadījumā datu bāzes nosaukums ir myGoappDB , ar Ziņas kā tās kolekcija.

Izveidojiet datu bāzes modeli

Izveidojiet jaunu mapi saknes direktorijā un izsauciet to modelis . Šī mape apstrādā jūsu datu bāzes modeli.

Izveidojiet jaunu Go failu šajā mapē un izsauciet to model.go . Šajā gadījumā jūsu modelis ir emuāra ziņa ar tā nosaukumu:

package model 
  
import ( 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
type Post struct { 
	ID      primitive.ObjectID 
	Title   string 
	Article string 
}

CRUD API izveide, izmantojot Go

Nākamais ir CRUD API izveide. Lai sāktu ar šo sadaļu, izveidojiet jaunu mapi projekta saknes direktorijā, lai apstrādātu galapunktus. Sauc to maršrutos .

Katrai darbībai šajā mapē izveidojiet atsevišķu Go failu. Piemēram, varat tos nosaukt izveidot.go , lasīt.iet , update.go , un delete.go . Jūs eksportēsit šos apdarinātājus kā maršrutos iepakojums.

Kā izveidot POST galapunktu programmā Go

Sāciet, definējot POST galapunktu, lai ierakstītu datus datu bāzē.

Iekšā routes/create.go , pievienojiet šo:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"log" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func CreatePost(c *gin.Context) { 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	post := new(model.Posts) 
	defer cancel() 
  
	if err := c.BindJSON(&post); err != nil { 
		c.JSON(http.StatusBadRequest, gin.H{"message": err}) 
		log.Fatal(err) 
		return 
	} 
  
	postPayload := model.Posts{ 
		Id:      primitive.NewObjectID(), 
		Title:   post.Title, 
		Article: post.Article, 
	} 
  
	result, err := postCollection.InsertOne(ctx, postPayload) 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "Posted successfully", "Data": map[string]interface{}{"data": result}}) 
} 

Šis kods sākas, importējot projekta pielāgotos moduļus. Pēc tam tas importē trešo pušu pakotnes, tostarp Džins un MongoDB draiveris .

Tālāk, postKolekcija glabā datubāzes kolekciju. Īpaši c.BindJSON('ziņa') ir JSONificēta modeļa instance, kas katru modeļa lauku izsauc kā pēcPayload ; tas nonāk datu bāzē.

Kā izveidot GET galapunktu

GET galapunkts, in maršruti/read.go , nolasa vienu dokumentu no datu bāzes, izmantojot tā unikālo ID. Tas sākas arī ar pielāgotu un trešo pušu pakotņu importēšanu:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func ReadOnePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
  
	postId := c.Param("postId") 
	var result model.Posts 
  
	defer cancel() 
  
	objId, _ := primitive.ObjectIDFromHex(postId) 
  
	err := postCollection.FindOne(ctx, bson.M{"id": objId}).Decode(&result) 
  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "success!", "Data": res}) 
} 

The ziņas mainīgais ir parametru deklarācija. Tas iegūst dokumenta objekta ID kā objId .

tomēr rezultāts ir datu bāzes modeļa gadījums, kas vēlāk satur atgriezto dokumentu kā res .

Kā izveidot PUT galapunktu

PUT apdarinātājs, iekšā routes/update.go , ir līdzīgs POST apstrādātājam. Šoreiz tas atjaunina esošu ziņu pēc tā unikālā objekta ID:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func UpdatePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second) 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
  
	postId := c.Param("postId") 
	var post model.Posts 
  
	defer cancel() 
  
	objId, _ := primitive.ObjectIDFromHex(postId) 
  
	if err := c.BindJSON(&post); err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	edited := bson.M{"title": post.Title, "article": post.Article} 
  
	result, err := postCollection.UpdateOne(ctx, bson.M{"id": objId}, bson.M{"$set": edited}) 
  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	if result.MatchedCount < 1 { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": "Data doesn't exist"}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "data updated successfully!", "Data": res}) 
} 

modeļa instances JSON formāts ( pastu ) izsauc katru modeļa lauku no datu bāzes. Rezultāta mainīgais izmanto MongoDB $set operatoru, lai atjauninātu nepieciešamo dokumentu, ko izsauc tā objekta ID.

The rezultāts.MatchedCount nosacījums neļauj kodam darboties, ja datu bāzē nav ierakstu vai nodotais ID ir nederīgs.

DELETE beigu punkta izveide

Galapunkts DELETE, in delete.go , noņem dokumentu, pamatojoties uz objekta ID, kas nodots kā URL parametrs:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func DeletePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	var DB = database.ConnectDB() 
	postId := c.Param("postId") 
  
	var postCollection = getcollection.GetCollection(DB, "Posts")  
	defer cancel() 
	objId, _ := primitive.ObjectIDFromHex(postId)  
	result, err := postCollection.DeleteOne(ctx, bson.M{"id": objId})  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	if result.DeletedCount < 1 { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": "No data to delete"}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "Article deleted successfully", "Data": res}) 
} 

Šis kods izdzēš ierakstu, izmantojot DeleteOne funkciju. Tas izmanto arī rezultāts.DeletedCount rekvizītu, lai novērstu koda palaišanu, ja datu bāze ir tukša vai objekta ID nav derīgs.

Izveidojiet API Runner failu

Visbeidzot izveidojiet a galvenais.go projekta saknes direktorijā. Jūsu galīgajai projekta struktūrai vajadzētu izskatīties šādi:

Šis fails apstrādā maršrutētāja izpildi katram galapunktam:

package main 
  
import ( 
    routes "CRUD_API/routes" 
    "github.com/gin-gonic/gin" 
) 
  
func main() { 
    router := gin.Default() 
  
    router.POST("/", routes.CreatePost) 
  
    // called as localhost:3000/getOne/{id} 
    router.GET("getOne/:postId", routes.ReadOnePost) 
  
    // called as localhost:3000/update/{id} 
    router.PUT("/update/:postId", routes.UpdatePost) 
  
    // called as localhost:3000/delete/{id} 
    router.DELETE("/delete/:postId", routes.DeletePost) 
  
    router.Run("localhost: 3000") 
} 

Šis fails ir galvenā pakotne, kurā darbojas citi faili. Tas sākas ar maršruta apstrādātāju importēšanu. Nākamais ir maršrutētājs mainīgais, a džins gadījums, kas izsauc HTTP darbības un izsauc katru galapunktu pēc tā funkcijas nosaukuma no maršrutos iepakojums.

Jūsu CRUD projekts turpinās vietējais saimnieks: 3000 . Lai palaistu serveri un pārbaudiet CRUD API , palaidiet šādu komandu savā bāzes direktorijā:

kā salabot tālruni, kas neieslēdzas līdz galam

go run main.go

Pārvērtiet savu Golang CRUD projektu par lietojamu produktu

Jūs esat veiksmīgi izveidojis CRUD API, izmantojot Go; apsveicu! Lai gan šis ir mazsvarīgs projekts, esat redzējis, kas nepieciešams, lai Go izpildītu parastos HTTP pieprasījumus.

Varat kļūt radošāks, paplašinot to par praktiskāku lietojumprogrammu, kas lietotājiem sniedz vērtību. Go ir piemērota programmēšanas valoda dažādiem lietošanas gadījumiem.