Golang är ett av de bäst betalande, efterfrågade programmeringsspråken med många applikationer. När du paras ihop med ramverk som Gin, Revel och gorilla/mux kan du enkelt skapa ett API med Go.

Lär dig hur du skapar ett CRUD API i Golang med hjälp av Gin HTTP-ramverket.

Initial installation och installation

Kom igång med Golang genom att installera det på din dator om du inte redan har gjort det.

När det är installerat är nästa steg att skapa en projektrotmapp på din dator och initiera en Go-modul i den rotkatalogen.

För att göra detta, öppna en CLI, navigera till din projektrotmapp och kör:

go mod init modulnamn

Du kommer att se ditt modulnamn (t.ex. CRUD_API) och dess version när du öppnar go.mod fil. Alla anpassade paket kommer från denna överordnade modul. Så alla importerade anpassade paket tar formen:

importera(paket CRUD_API/paket-katalognamn)

Installera sedan de paket som krävs för att skapa CRUD API. Använd i det här fallet Gin Gonic för att dirigera API-slutpunkterna:

gå skaffa sig github.com/gin-gonic/gin
instagram viewer

Installera nu MongoDB-drivrutinen för att lagra data:

gå skaffa sig go.mongodb.org/mongo-driver/mongo

Hur man ansluter Gå till MongoDB

Allt du behöver är din MongoDB URI för att koppla Golang till databasen. Det ser vanligtvis ut så här om du ansluter till MongoDB Atlas lokalt:

Mongo_URL = "mongodb://127.0.0.1:27017"

Skapa nu en ny mapp i ditt projekts rotkatalog och anrop den databaser. Skapa en Go-fil i den här mappen och namnge den database.go.

Detta är ditt databaspaket, och det börjar med att importera de nödvändiga biblioteken:

paket databas
importera (
"sammanhang"
"fmt"
"logga"
"tid"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)


func ConnectDB() *mongo. Klient {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	klient, err := mongo. NewClient (alternativ. Client().ApplyURI(Mongo_URL))


om fel != noll {
logga.Dödlig(fela)
	}


ctx, avbryt := sammanhang. WithTimeout (sammanhang. Bakgrund(), 10 * tid. Andra)
	err = klient. Anslut (ctx)
	defer cancel()


om fel != noll {
logga.Dödlig(fela)
	}
fmt. Println("Ansluten till mongoDB")
lämna tillbaka klient
}

Det är bästa praxis att dölja miljövariabler som databasanslutningssträngen i en .env fil använder dotenv-paketet. Detta gör din kod mer portabel och kommer väl till pass när du använder en MongoDB molnklusterinstans, till exempel.

De ConnectDB funktionen upprättar en anslutning och returnerar ett nytt MongoDB Client-objekt.

Skapa databassamling

MongoDB lagrar data i samlingar, som ger ett gränssnitt till underliggande databasdata.

För att hantera samlingshämtningsfunktionen, börja med att skapa en ny mapp, Samling, i din projektrot. Skapa nu en ny Go-fil, getCollection.go, som hämtar samlingen från databasen:

paket getcollection
importera (
"go.mongodb.org/mongo-driver/mongo"
)
funcGetCollection(klient *mongo.Klient, samlingsnamnsträng) *mongo.Samling {
	samling := klient. Databas("myGoappDB").Samling("Inlägg")
lämna tillbaka samling
}

Denna funktion hämtar samlingen från MongoDB-databasen. Databasnamnet, i det här fallet, är myGoappDB, med Inlägg som sin samling.

Skapa databasmodellen

Skapa en ny mapp i din rotkatalog och anropa den modell. Den här mappen hanterar din databasmodell.

Skapa en ny Go-fil i den mappen och anropa den model.go. Din modell, i det här fallet, är ett blogginlägg med dess titel:

paket modell
importera (
"go.mongodb.org/mongo-driver/bson/primitive"
)
typ Post struct {
IDprimitiv.Objekt-ID
	Titelsträng
	Artikelsträng
}

Skapa ett CRUD API med Go

Nästa upp är CRUD API-skapandet. För att börja med det här avsnittet, skapa en ny mapp i projektets rotkatalog för att hantera dina slutpunkter. Kalla det rutter.

Skapa en separat Go-fil i den här mappen för varje åtgärd. Du kan till exempel namnge dem create.go, läs.gå, update.go, och delete.go. Du exporterar dessa hanterare som rutter paket.

Hur man skapar POST-slutpunkten i Go

Börja med att definiera POST-slutpunkten för att skriva data till databasen.

Inuti routes/create.go, lägg till följande:

paket rutter
importera (
	getcollection "CRUD_API/samling"
	databas "CRUD_API/databaser"
	modell "CRUD_API/modell"
"sammanhang"
"logga"
"net/http"
"tid"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func Skapa inlägg(c *gin. Sammanhang){
var DB = databas. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Inlägg")
	ctx, avbryt := sammanhang. WithTimeout (sammanhang. Bakgrund(), 10*tid. Andra)
	inlägg := ny(modell. inlägg)
	defer cancel()


om fel := c. BindJSON(&posta); fel != noll {
 c. JSON(http. StatusBadRequest, gin. H{"meddelande": err})
logga.Dödlig(fela)
lämna tillbaka
	}


postPayload := modell. Inlägg{
Id: primitiv.NewObjectID(),
Titel: posta.Titel,
Artikel: posta.Artikel,
	}


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


om fel != noll {
 c. JSON(http. StatusInternalServerError, gin. H{"meddelande": err})
lämna tillbaka
	}
c. JSON(http. StatusCreated, gin. H{"meddelande": "Upplagt framgångsrikt", "Data": kart[sträng]gränssnitt{}{"data": resultat}})
}

Denna kod börjar med att importera projektets anpassade moduler. Den importerar sedan tredjepartspaket inklusive Gin och Drivrutinen för MongoDB.

Ytterligare, postsamling innehar databassamlingen. I synnerhet, c. BindJSON("post") är en JSONifierad modellinstans som anropar varje modellfält som postPayload; detta går in i databasen.

Hur man skapar GET-slutpunkten

GET-slutpunkten, in routes/read.go, läser ett enstaka dokument från databasen via dess unika ID. Det börjar också med att importera anpassade och tredjepartspaket:

paket rutter
importera (
	getcollection "CRUD_API/samling"
	databas "CRUD_API/databaser"
	modell "CRUD_API/modell"
"sammanhang"
"net/http"
"tid"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func ReadOnePost(c *gin. Sammanhang){
	ctx, avbryt := sammanhang. WithTimeout (sammanhang. Bakgrund(), 10*tid. Andra)
var DB = databas. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Inlägg")


postId := c. Param("postId")
var resultatmodell. Inlägg


defer cancel()


objId, _ := primitiv. ObjectIDFromHex (postId)


err := postCollection. FindOne (ctx, bson. M{"id": objId}).Decode(&resultat)


res := karta[sträng]gränssnitt{}{"data": resultat}


om fel != noll {
 c. JSON(http. StatusInternalServerError, gin. H{"meddelande": err})
lämna tillbaka
	}
c. JSON(http. StatusCreated, gin. H{"meddelande": "Framgång!", "Data": res})
}

De postId variabel är en parameterdeklaration. Den får ett dokuments objekt-ID som objId.

I alla fall, resultat är en instans av databasmodellen, som senare håller det returnerade dokumentet som res.

Hur man skapar PUT Endpoint

PUT-hanteraren, in routes/update.go, liknar POST-hanteraren. Den här gången uppdaterar den ett befintligt inlägg med dess unika objekt-ID:

paket rutter
importera (
	getcollection "CRUD_API/samling"
	databas "CRUD_API/databaser"
	modell "CRUD_API/modell"
"sammanhang"
"net/http"
"tid"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func UpdatePost(c *gin. Sammanhang){
	ctx, avbryt := sammanhang. WithTimeout (sammanhang. Bakgrund(), 10 * tid. Andra)
var DB = databas. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Inlägg")


postId := c. Param("postId")
var stolpemodell. Inlägg


defer cancel()


objId, _ := primitiv. ObjectIDFromHex (postId)


om fel := c. BindJSON(&posta); fel != noll {
 c. JSON(http. StatusInternalServerError, gin. H{"meddelande": err})
lämna tillbaka
	}


redigerat := bson. M{"titel": inlägg. Titel, "artikel": inlägg. Artikel}


resultat, err := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$set": redigerad})


res := karta[sträng]gränssnitt{}{"data": resultat}


om fel != noll {
 c. JSON(http. StatusInternalServerError, gin. H{"meddelande": err})
lämna tillbaka
	}


om resultatet. MatchedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"meddelande": "Data gör det't existerar"})
lämna tillbaka
	}
c. JSON(http. StatusCreated, gin. H{"meddelande": "data har uppdaterats framgångsrikt!", "Data": res})
}

Ett JSON-format för modellinstansen (posta) anropar varje modellfält från databasen. Resultatvariabeln använder MongoDB $set operatör för att uppdatera ett obligatoriskt dokument som anropas av dess objekt-ID.

De resultat. MatchedCount villkor förhindrar att koden körs om det inte finns någon post i databasen eller om det skickade ID: t är ogiltigt.

Skapa en DELETE-slutpunkt

DELETE-slutpunkten, in delete.go, tar bort ett dokument baserat på det objekt-ID som skickats som en URL-parameter:

paket rutter
importera (
	getcollection "CRUD_API/samling"
	databas "CRUD_API/databaser"
"sammanhang"
"net/http"
"tid"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func Ta bort inlägg(c *gin. Sammanhang){
	ctx, avbryt := sammanhang. WithTimeout (sammanhang. Bakgrund(), 10*tid. Andra)
var DB = databas. ConnectDB()
	postId := c. Param("postId")


var postCollection = getcollection. GetCollection (DB, "Inlägg") 
	defer cancel()
	objId, _ := primitiv. ObjectIDFromHex (postId) 
	resultat, err := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := karta[sträng]gränssnitt{}{"data": resultat}


om fel != noll {
 c. JSON(http. StatusInternalServerError, gin. H{"meddelande": err})
lämna tillbaka
	}


om resultatet. DeletedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"meddelande": "Ingen data att radera"})
lämna tillbaka
	}
c. JSON(http. StatusCreated, gin. H{"meddelande": "Artikel raderades framgångsrikt", "Data": res})
}

Denna kod tar bort en post med hjälp av DeleteOne fungera. Den använder också resultat. DeletedCount egenskap för att förhindra att koden körs om databasen är tom eller om objekt-ID är ogiltigt.

Skapa API Runner-filen

Slutligen, skapa en main.go i ditt projekts rotkatalog. Din slutliga projektstruktur bör se ut så här:

Den här filen hanterar routerkörning för varje slutpunkt:

paket huvud
importera (
 rutter "CRUD_API/rutter"
"github.com/gin-gonic/gin"
)


func huvud(){
 router := gin.Standard()


router. POSTA("/", rutter. Skapa inlägg)


// anropad som localhost: 3000/getOne/{id}
 router. SKAFFA SIG("getOne/:postId", rutter. ReadOnePost)


// anropad som lokal värd: 3000/uppdatering/{id}
 router. SÄTTA("/update/:postId", rutter. UpdatePost)


// anropad som lokal värd: 3000/radera/{id}
 router. RADERA("/radera/:postId", rutter. Ta bort inlägg)
router. Springa("lokal värd: 3000")
}

Den här filen är huvudpaketet som kör andra filer. Det börjar med att importera rutthanterarna. Nästa är router variabel, a gin instans som framkallar HTTP-åtgärderna och anropar varje slutpunkt med dess funktionsnamn från rutter paket.

Ditt CRUD-projekt fortsätter lokal värd: 3000. För att köra servern och testa CRUD API, kör följande kommando i din baskatalog:

gåspringahuvud.gå

Förvandla ditt Golang CRUD-projekt till en användbar produkt

Du har framgångsrikt skapat ett CRUD API med Go; grattis! Även om detta är ett mindre projekt, har du sett vad som krävs för att utföra vanliga HTTP-förfrågningar i Go.

Du kan bli mer kreativ genom att utöka detta till en mer praktisk applikation som levererar värde till användarna. Go är ett lämpligt programmeringsspråk för en rad användningsfall.