கோலாங்கின் ஜின் மற்றும் மோங்கோடிபி மூலம் CRUD API ஐ உருவாக்குவது எப்படி

கோலாங் என்பது பல பயன்பாடுகளுடன் அதிக பணம் செலுத்தும், தேவைக்கேற்ப நிரலாக்க மொழிகளில் ஒன்றாகும். Gin, Revel மற்றும் gorilla/mux போன்ற கட்டமைப்புகளுடன் இணைக்கப்படும்போது, ​​Go உடன் APIயை எளிதாக உருவாக்கலாம்.

Gin HTTP கட்டமைப்பைப் பயன்படுத்தி Golang இல் CRUD API ஐ எவ்வாறு உருவாக்குவது என்பதை அறிக.

---

---

அன்றைய வீடியோவை உருவாக்கவும்

ஆரம்ப அமைப்பு மற்றும் நிறுவல்

கோலாங்குடன் தொடங்கவும் நீங்கள் ஏற்கனவே அவ்வாறு செய்யவில்லை என்றால், அதை உங்கள் கணினியில் நிறுவுவதன் மூலம்.

நிறுவப்பட்டதும், அடுத்த படியாக உங்கள் கணினியில் திட்ட ரூட் கோப்புறையை உருவாக்கி அந்த ரூட் கோப்பகத்தில் Go தொகுதியை துவக்க வேண்டும்.

இதைச் செய்ய, திறக்கவும் ஒரு CLI , உங்கள் திட்ட ரூட் கோப்புறையில் சென்று இயக்கவும்:

go mod init module_name 

உங்கள் தொகுதியின் பெயரைக் காண்பீர்கள் (எ.கா. CRUD_API ) மற்றும் நீங்கள் திறக்கும் போது அதன் பதிப்பு go.mod கோப்பு. அனைத்து தனிப்பயன் தொகுப்புகளும் இந்த பெற்றோர் தொகுதியிலிருந்து வரும். எனவே எந்த இறக்குமதி செய்யப்பட்ட தனிப்பயன் தொகுப்பு படிவத்தை எடுக்கும்:

விளையாட்டை வேகமாக பதிவிறக்குவது எப்படி

import(package CRUD_API/package-directory-name)

அடுத்து, CRUD API ஐ உருவாக்க தேவையான தொகுப்புகளை நிறுவவும். இந்த வழக்கில், பயன்படுத்தவும் ஜின் கோனிக் ஏபிஐ இறுதிப்புள்ளிகளை வழிநடத்த:

---

---

go get github.com/gin-gonic/gin 

இப்போது மோங்கோடிபி டிரைவரை நிறுவி தரவைச் சேமிக்கவும்:

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

மோங்கோடிபிக்கு எவ்வாறு இணைப்பது

கோலாங்கை தரவுத்தளத்துடன் இணைக்க, உங்களுக்கு மொங்கோடிபி யுஆர்ஐ மட்டுமே தேவை. நீங்கள் மோங்கோடிபி அட்லஸுடன் உள்நாட்டில் இணைக்கிறீர்கள் என்றால் பொதுவாக இது போல் தெரிகிறது:

---

---

Mongo_URL = "mongodb://127.0.0.1:27017"

இப்போது உங்கள் திட்ட ரூட் கோப்பகத்தில் புதிய கோப்புறையை உருவாக்கி அதை அழைக்கவும் தரவுத்தளங்கள் . இந்தக் கோப்புறைக்குள் Go கோப்பை உருவாக்கி அதற்குப் பெயரிடவும் database.go .

இது உங்கள் தரவுத்தள தொகுப்பு, தேவையான நூலகங்களை இறக்குமதி செய்வதன் மூலம் இது தொடங்குகிறது:

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 
} 

ஒரு தரவுத்தள இணைப்பு சரம் போன்ற சூழல் மாறிகளை மறைப்பது சிறந்த நடைமுறை .env கோப்பு dotenv தொகுப்பைப் பயன்படுத்தி . இது உங்கள் குறியீட்டை மேலும் எடுத்துச் செல்லக்கூடியதாக ஆக்குகிறது மற்றும் ஒரு பயன்படுத்தும் போது கைக்கு வரும் மோங்கோடிபி கிளவுட் கிளஸ்டர் நிகழ்வு , உதாரணத்திற்கு.

தி ConnectDB செயல்பாடு ஒரு இணைப்பை நிறுவுகிறது மற்றும் ஒரு புதிய MongoDB கிளையண்ட் பொருளை வழங்குகிறது.

தரவுத்தள சேகரிப்பை உருவாக்கவும்

MongoDB சேகரிப்புகளில் தரவைச் சேமிக்கிறது, இது அடிப்படை தரவுத்தளத் தரவுகளுக்கு இடைமுகத்தை வழங்குகிறது.

சேகரிப்பு-பெறுதல் செயல்பாட்டைக் கையாள, புதிய கோப்புறையை உருவாக்குவதன் மூலம் தொடங்கவும், சேகரிப்பு , உங்கள் திட்ட மூலத்தில். இப்போது புதிய Go கோப்பை உருவாக்கவும், getCollection.go , இது தரவுத்தளத்திலிருந்து சேகரிப்பைப் பெறுகிறது:

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 
} 

இந்தச் செயல்பாடு MongoDB தரவுத்தளத்திலிருந்து சேகரிப்பைப் பெறுகிறது. இந்த வழக்கில் தரவுத்தளத்தின் பெயர் myGoappDB , உடன் இடுகைகள் அதன் தொகுப்பாக.

யூடியூப்பில் பார்க்க சிறந்த விஷயம்

தரவுத்தள மாதிரியை உருவாக்கவும்

உங்கள் ரூட் கோப்பகத்தில் ஒரு புதிய கோப்புறையை உருவாக்கி அதை அழைக்கவும் மாதிரி . இந்தக் கோப்புறை உங்கள் தரவுத்தள மாதிரியைக் கையாளுகிறது.

அந்த கோப்புறைக்குள் புதிய Go கோப்பை உருவாக்கி அதை அழைக்கவும் மாதிரி.போ . உங்கள் மாதிரி, இந்த விஷயத்தில், அதன் தலைப்புடன் ஒரு வலைப்பதிவு இடுகை:

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

Go உடன் CRUD API ஐ உருவாக்குதல்

அடுத்தது CRUD API உருவாக்கம். இந்தப் பிரிவைத் தொடங்க, உங்கள் இறுதிப் புள்ளிகளைக் கையாள உங்கள் திட்ட ரூட் கோப்பகத்தில் புதிய கோப்புறையை உருவாக்கவும். அதை அழைக்கவும் பாதைகள் .

ஒவ்வொரு செயலுக்கும் இந்தக் கோப்புறையில் தனி Go கோப்பை உருவாக்கவும். உதாரணமாக, நீங்கள் அவர்களை பெயரிடலாம் உருவாக்கு.போ , படிக்க.போ , update.go , மற்றும் delete.go . இந்த ஹேண்ட்லர்களை நீங்கள் ஏற்றுமதி செய்வீர்கள் பாதைகள் தொகுப்பு.

Go இல் POST எண்ட்பாயிண்ட்டை உருவாக்குவது எப்படி

தரவுத்தளத்தில் தரவை எழுத POST இறுதிப்புள்ளியை வரையறுப்பதன் மூலம் தொடங்கவும்.

உள்ளே வழிகள்/create.go , பின்வருவனவற்றைச் சேர்க்கவும்:

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}}) 
} 

திட்டத்தின் தனிப்பயன் தொகுதிகளை இறக்குமதி செய்வதன் மூலம் இந்தக் குறியீடு தொடங்குகிறது. இது உள்ளிட்ட மூன்றாம் தரப்பு தொகுப்புகளை இறக்குமதி செய்கிறது ஜின் மற்றும் மோங்கோடிபி டிரைவர் .

மேலும், பிந்தைய சேகரிப்பு தரவுத்தள சேகரிப்பை வைத்திருக்கிறது. குறிப்பிடத்தக்கது, c.BindJSON('post') JSONified மாதிரி நிகழ்வாகும், இது ஒவ்வொரு மாதிரி புலத்தையும் இவ்வாறு அழைக்கிறது போஸ்ட் பேலோட் ; இது தரவுத்தளத்தில் செல்கிறது.

GET எண்ட்பாயிண்ட்டை எவ்வாறு உருவாக்குவது

GET இறுதிப்புள்ளி, in வழிகள்/read.go , தரவுத்தளத்திலிருந்து ஒரு ஆவணத்தை அதன் தனிப்பட்ட ஐடி மூலம் படிக்கிறது. தனிப்பயன் மற்றும் மூன்றாம் தரப்பு தொகுப்புகளை இறக்குமதி செய்வதன் மூலமும் இது தொடங்குகிறது:

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}) 
} 

தி இடுகைகள் மாறி என்பது ஒரு அளவுரு அறிவிப்பு. இது ஒரு ஆவணத்தின் பொருள் ஐடியைப் பெறுகிறது objId .

எனினும், விளைவாக தரவுத்தள மாதிரியின் ஒரு எடுத்துக்காட்டு, இது பின்னர் திரும்பிய ஆவணத்தை வைத்திருக்கிறது ரெஸ் .

PUT எண்ட்பாயிண்ட்டை எவ்வாறு உருவாக்குவது

PUT கையாளுபவர், in வழிகள்/update.go , POST கையாளுதலைப் போன்றது. இந்த நேரத்தில், அது ஏற்கனவே உள்ள இடுகையை அதன் தனித்துவமான பொருள் ஐடி மூலம் புதுப்பிக்கிறது:

சிபியு 100 விண்டோஸ் 7 இல் இயங்குகிறது

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}) 
} 

மாதிரி நிகழ்வின் JSON வடிவம் ( அஞ்சல் ) தரவுத்தளத்திலிருந்து ஒவ்வொரு மாதிரி புலத்தையும் அழைக்கிறது. முடிவு மாறி மோங்கோடிபியைப் பயன்படுத்துகிறது $செட் ஆபரேட்டர் தேவையான ஆவணத்தை அதன் ஆப்ஜெக்ட் ஐடி மூலம் புதுப்பிக்க வேண்டும்.

தி முடிவு. பொருந்திய எண்ணிக்கை தரவுத்தளத்தில் எந்தப் பதிவும் இல்லாவிட்டால் அல்லது அனுப்பப்பட்ட ஐடி தவறானதாக இருந்தால், குறியீடு இயங்குவதை நிபந்தனை தடுக்கிறது.

DELETE Endpoint ஐ உருவாக்குகிறது

DELETE இறுதிப்புள்ளி, in delete.go , URL அளவுருவாக அனுப்பப்பட்ட பொருள் ஐடியின் அடிப்படையில் ஒரு ஆவணத்தை நீக்குகிறது:

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}) 
} 

இந்தக் குறியீடு இதைப் பயன்படுத்தி ஒரு பதிவை நீக்குகிறது ஒன்றை நீக்கு செயல்பாடு. இதுவும் பயன்படுத்துகிறது முடிவு.DeletedCount தரவுத்தளம் காலியாக இருந்தால் அல்லது ஆப்ஜெக்ட் ஐடி தவறானதாக இருந்தால் குறியீடு இயங்குவதைத் தடுக்கும் பண்பு.

API ரன்னர் கோப்பை உருவாக்கவும்

இறுதியாக, உருவாக்கவும் முக்கிய.go உங்கள் திட்ட ரூட் கோப்பகத்தின் உள்ளே. உங்கள் இறுதி திட்ட அமைப்பு இப்படி இருக்க வேண்டும்:

இந்த கோப்பு ஒவ்வொரு இறுதிப்புள்ளிக்கும் திசைவி இயக்கத்தை கையாளுகிறது:

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") 
} 

இந்த கோப்பு மற்ற கோப்புகளை இயக்கும் முக்கிய தொகுப்பு ஆகும். இது ரூட் ஹேண்ட்லர்களை இறக்குமதி செய்வதன் மூலம் தொடங்குகிறது. அடுத்தது தி திசைவி மாறி, a ஜின் HTTP செயல்களைத் தூண்டி, ஒவ்வொரு முனைப்புள்ளியையும் அதன் செயல்பாட்டுப் பெயரால் அழைக்கிறது பாதைகள் தொகுப்பு.

உங்கள் CRUD திட்டம் இயங்குகிறது லோக்கல் ஹோஸ்ட்:3000 . சேவையகத்தை இயக்க மற்றும் CRUD API ஐ சோதிக்கவும் , உங்கள் அடிப்படை கோப்பகத்தில் பின்வரும் கட்டளையை இயக்கவும்:

go run main.go

உங்கள் Golang CRUD திட்டத்தை பயன்படுத்தக்கூடிய தயாரிப்பாக மாற்றவும்

Go உடன் CRUD APIயை வெற்றிகரமாக உருவாக்கியுள்ளீர்கள்; வாழ்த்துக்கள்! இது சிறிய திட்டமாக இருந்தாலும், வழக்கமான HTTP கோரிக்கைகளை Goவில் செயல்படுத்த என்ன தேவை என்பதை நீங்கள் பார்த்திருக்கிறீர்கள்.

பயனர்களுக்கு மதிப்பை வழங்கும் மிகவும் நடைமுறை பயன்பாடாக இதை விரிவுபடுத்துவதன் மூலம் நீங்கள் மேலும் படைப்பாற்றலைப் பெறலாம். Go என்பது பல்வேறு பயன்பாட்டு நிகழ்வுகளுக்கு பொருத்தமான நிரலாக்க மொழியாகும்.