Kuinka luoda CRUD-sovellusliittymä Golang's Ginin ja MongoDB:n avulla

Kuinka luoda CRUD-sovellusliittymä Golang's Ginin ja MongoDB:n avulla

Golang on yksi eniten maksavista, kysytyistä ohjelmointikielistä, jossa on monia sovelluksia. Kun yhdistät kehykset, kuten Gin, Revel ja gorilla/mux, voit helposti luoda API:n Golla.





Opi luomaan CRUD API Golangissa Gin HTTP -kehyksen avulla.



PÄIVÄN VIDEON TEKEMINEN

Alkuasennus ja asennus

Aloita Golangin kanssa asentamalla sen tietokoneellesi, jos et ole jo tehnyt niin.





Asennuksen jälkeen seuraava vaihe on luoda projektin juurikansio koneellesi ja alustaa Go-moduuli kyseiseen juurihakemistoon.

Voit tehdä tämän avaamalla CLI , siirry projektisi juurikansioon ja suorita:



go mod init module_name

Näet moduulisi nimen (esim. CRUD_API ) ja sen versio, kun avaat go.mod tiedosto. Kaikki mukautetut paketit tulevat tästä ylämoduulista. Joten mikä tahansa tuotu mukautettu paketti on muodossa:

import(package CRUD_API/package-directory-name)

Asenna seuraavaksi CRUD API:n luomiseen tarvittavat paketit. Käytä tässä tapauksessa Gin Gonic reitittääksesi API-päätepisteet:



go get github.com/gin-gonic/gin

Asenna nyt MongoDB-ohjain tietojen tallentamiseksi:

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

Yhteyden muodostaminen Siirry MongoDB:hen

Tarvitset vain MongoDB URI:si yhdistääksesi Golangin tietokantaan. Se näyttää yleensä tältä, jos muodostat yhteyden MongoDB Atlasiin paikallisesti:



Mongo_URL = "mongodb://127.0.0.1:27017"

Luo nyt uusi kansio projektisi juurihakemistoon ja kutsu se tietokannat . Luo Go-tiedosto tähän kansioon ja nimeä se tietokanta.go .

Tämä on tietokantapakettisi, ja se alkaa tuomalla tarvittavat kirjastot:

kuinka nopeuttaa torrentin lataamista 
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 
}

On paras käytäntö piilottaa ympäristömuuttujat, kuten tietokantayhteysmerkkijono a:ssa .env tiedosto käyttämällä dotenv-pakettia . Tämä tekee koodistasi kannettavamman ja on kätevä, kun käytät a MongoDB-pilviklusterin ilmentymä , esimerkiksi.

The ConnectDB toiminto muodostaa yhteyden ja palauttaa uuden MongoDB Client -objektin.

Luo tietokantakokoelma

MongoDB tallentaa tiedot kokoelmiin, jotka tarjoavat käyttöliittymän taustalla oleviin tietokantatietoihin.

Voit hoitaa kokoelman noutotoiminnon luomalla uuden kansion, Kokoelma , projektisi juuressa. Luo nyt uusi Go-tiedosto, getCollection.go , joka saa kokoelman tietokannasta:

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 
}

Tämä toiminto saa kokoelman MongoDB-tietokannasta. Tietokannan nimi tässä tapauksessa on myGoappDB , kanssa Viestit sen kokoelmana.

Luo tietokantamalli

Tee uusi kansio juurihakemistoosi ja kutsu se malli- . Tämä kansio käsittelee tietokantamalliasi.

Luo uusi Go-tiedosto kyseiseen kansioon ja kutsu se model.go . Mallisi on tässä tapauksessa blogikirjoitus, jonka otsikko on:

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

CRUD API:n luominen Golla

Seuraavaksi luodaan CRUD API. Aloita tästä osiosta luomalla projektisi juurihakemistoon uusi kansio päätepisteiden käsittelemistä varten. Kutsu sitä reitit .

Luo erillinen Go-tiedosto tähän kansioon kullekin toiminnolle. Voit esimerkiksi nimetä ne luo.go , read.go , update.go , ja delete.go . Vie nämä käsittelijät nimellä reitit paketti.

POST-päätepisteen luominen Gossa

Aloita määrittämällä POST-päätepiste tietojen kirjoittamiseksi tietokantaan.

Sisällä routes/create.go , lisää seuraavat:

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

Tämä koodi alkaa tuomalla projektin mukautetut moduulit. Sitten se tuo kolmannen osapuolen paketteja, mukaan lukien Gin ja MongoDB-ohjain .

Edelleen, postCollection sisältää tietokantakokoelman. Erityisesti c.BindJSON('viesti') on JSONified-mallin ilmentymä, joka kutsuu jokaista mallikenttää nimellä postPayload ; tämä menee tietokantaan.

Kuinka luoda GET-päätepiste

GET-päätepiste, sisään routes/read.go , lukee yksittäisen asiakirjan tietokannasta yksilöllisen tunnuksensa kautta. Se alkaa myös tuomalla mukautettuja ja kolmannen osapuolen paketteja:

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 viestit muuttuja on parametrimääritys. Se saa asiakirjan objektitunnuksen muodossa objId .

Kuitenkin, tulos on tietokantamallin esiintymä, joka sisältää myöhemmin palautetun asiakirjan muodossa res .

Kuinka luoda PUT-päätepiste

PUT-käsittelijä, sisään routes/update.go , on samanlainen kuin POST-käsittelijä. Tällä kertaa se päivittää olemassa olevan viestin ainutlaatuisella objektitunnuksellaan:

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

Mallin esiintymän JSON-muoto ( lähettää ) kutsuu jokaista mallikenttää tietokannasta. Tulosmuuttuja käyttää MongoDB:tä $set operaattori päivittää vaaditun asiakirjan, jota kutsutaan sen objektitunnuksella.

xbox one -ohjaimen asentaminen tietokoneeseen

The result.MatchedCount ehto estää koodin suorittamisen, jos tietokannassa ei ole tietueita tai välitetty tunnus on virheellinen.

Luodaan DELETE-päätepistettä

DELETE-päätepiste, sisään delete.go , poistaa asiakirjan URL-parametrina välitetyn objektitunnuksen perusteella:

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

Tämä koodi poistaa tietueen käyttämällä DeleteOne toiminto. Se käyttää myös result.DeletedCount -ominaisuus estää koodin suorittamisen, jos tietokanta on tyhjä tai objektin tunnus on virheellinen.

Luo API Runner -tiedosto

Luo lopuksi a main.go projektisi juurihakemistossa. Lopullisen projektisi rakenteen pitäisi näyttää tältä:

Golang CRUD -projektin rakenne

Tämä tiedosto käsittelee reitittimen suorittamisen jokaiselle päätepisteelle:

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

Tämä tiedosto on pääpaketti, joka suorittaa muita tiedostoja. Se alkaa tuomalla reittikäsittelijät. Seuraava on reititin muuttuja, a gin esiintymä, joka herättää HTTP-toiminnot ja kutsuu jokaista päätepistettä sen funktion nimellä reitit paketti.

CRUD-projektisi jatkuu paikallinen isäntä: 3000 . Palvelimen ajamiseen ja testaa CRUD API:ta , suorita seuraava komento perushakemistossasi:

go run main.go

Tee Golang CRUD -projektistasi käyttökelpoinen tuote

Olet onnistuneesti luonut CRUD API:n Golla; Onnittelut, Vaikka tämä on pieni projekti, olet nähnyt, mitä tavallisten HTTP-pyyntöjen suorittaminen vaatii Gossa.

Voit saada lisää luovuutta laajentamalla tätä käytännöllisemmäksi sovellukseksi, joka tuottaa arvoa käyttäjille. Go on sopiva ohjelmointikieli useisiin käyttötarkoituksiin.