Golang er et av de best betalende, etterspurte programmeringsspråkene med mange applikasjoner. Når du er sammenkoblet med rammeverk som Gin, Revel og gorilla/mux, kan du enkelt lage et API med Go.

Lær hvordan du lager en CRUD API i Golang ved å bruke Gin HTTP-rammeverket.

Første oppsett og installasjon

Kom i gang med Golang ved å installere den på datamaskinen din hvis du ikke allerede har gjort det.

Når det er installert, er neste trinn å opprette en prosjektrotmappe på maskinen din og initialisere en Go-modul i den rotkatalogen.

For å gjøre dette, åpne en CLI, naviger til prosjektets rotmapp og kjør:

go mod init modulnavn

Du vil se modulnavnet ditt (f.eks. CRUD_API) og versjonen når du åpner go.mod fil. Alle tilpassede pakker kommer fra denne overordnede modulen. Så enhver importert tilpasset pakke tar formen:

import(pakke CRUD_API/pakke-katalognavn)

Installer deretter pakkene som er nødvendige for å lage CRUD API. I dette tilfellet, bruk Gin Gonic for å rute API-endepunktene:

gå få github.com/gin-gonic/gin
instagram viewer

Installer nå MongoDB-driveren for å lagre data:

gå få go.mongodb.org/mongo-driver/mongo

Slik kobler du til Gå til MongoDB

Alt du trenger er MongoDB URI for å koble Golang med databasen. Det ser vanligvis slik ut hvis du kobler til MongoDB Atlas lokalt:

Mongo_URL = "mongodb://127.0.0.1:27017"

Opprett nå en ny mappe i prosjektets rotkatalog og kall den databaser. Opprett en Go-fil i denne mappen og navngi den database.go.

Dette er databasepakken din, og den starter med å importere de nødvendige bibliotekene:

pakke database
import (
"kontekst"
"fmt"
"Logg"
"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, feil := mongo. NewClient (alternativer. Client().ApplyURI(Mongo_URL))


hvis feil != null {
Logg.Fatal(feil)
	}


ctx, avbryt := kontekst. WithTimeout (kontekst. Bakgrunn(), 10 * tid. Sekund)
	feil = klient. Koble til (ctx)
	utsett avbryt()


hvis feil != null {
Logg.Fatal(feil)
	}
fmt. Println("Koblet til mongoDB")
komme tilbake klient
}

Det er best praksis å skjule miljøvariabler som databasetilkoblingsstrengen i en .env fil ved å bruke dotenv-pakken. Dette gjør koden din mer bærbar og kommer godt med når du bruker en MongoDB skyklyngeforekomst, for eksempel.

De ConnectDB funksjonen etablerer en tilkobling og returnerer et nytt MongoDB Client-objekt.

Opprett databasesamling

MongoDB lagrer data i samlinger, som gir et grensesnitt til de underliggende databasedataene.

For å håndtere samlingshentingsfunksjonaliteten, start med å opprette en ny mappe, Samling, i prosjektroten din. Opprett nå en ny Go-fil, getCollection.go, som henter samlingen fra databasen:

pakke getsamling
import (
"go.mongodb.org/mongo-driver/mongo"
)
funcGetCollection(klient *mongo.Klient, samlingsnavnstreng) *mongo.Samling {
	samling := klient. Database("myGoappDB").Samling("Innlegg")
komme tilbake samling
}

Denne funksjonen henter samlingen fra MongoDB-databasen. Databasenavnet, i dette tilfellet, er myGoappDB, med Innlegg som sin samling.

Lag databasemodellen

Lag en ny mappe i rotkatalogen din og ring den modell. Denne mappen håndterer databasemodellen din.

Opprett en ny Go-fil i den mappen og ring den model.go. Modellen din, i dette tilfellet, er et blogginnlegg med tittelen:

pakke modell
import (
"go.mongodb.org/mongo-driver/bson/primitive"
)
type Post struct {
IDprimitiv.Objekt-ID
	Tittelstreng
	Artikkelstreng
}

Opprette et CRUD API med Go

Neste opp er opprettelsen av CRUD API. For å starte med denne delen, lag en ny mappe i prosjektets rotkatalog for å håndtere endepunktene dine. Kall det ruter.

Lag en egen Go-fil i denne mappen for hver handling. Du kan for eksempel navngi dem create.go, les.gå, update.go, og delete.go. Du eksporterer disse behandlerne som ruter pakke.

Hvordan lage POST-endepunktet i Go

Start med å definere POST-endepunktet for å skrive data inn i databasen.

Innsiden routes/create.go, legg til følgende:

pakke ruter
import (
	getsamling "CRUD_API/samling"
	database "CRUD_API/databaser"
	modell "CRUD_API/modell"
"kontekst"
"Logg"
"net/http"
"tid"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func CreatePost(c *gin. Kontekst){
var DB = database. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Innlegg")
	ctx, avbryt := kontekst. WithTimeout (kontekst. Bakgrunn(), 10*tid. Sekund)
	innlegg := ny(modell. innlegg)
	utsett avbryt()


hvis feil := c. BindJSON(&post); feil != null {
 c. JSON(http. StatusBadRequest, gin. H{"beskjed": feil})
Logg.Fatal(feil)
komme tilbake
	}


postPayload := modell. Innlegg{
ID: primitiv.NewObjectID(),
Tittel: post.Tittel,
Artikkel: post.Artikkel,
	}


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


hvis feil != null {
 c. JSON(http. StatusInternalServerError, gin. H{"beskjed": feil})
komme tilbake
	}
c. JSON(http. StatusCreated, gin. H{"beskjed": "Lagt ut", "Data": kart[streng]grensesnitt{}{"data": resultat}})
}

Denne koden starter med å importere prosjektets egendefinerte moduler. Den importerer deretter tredjepartspakker inkludert Gin og MongoDB-driver.

Lengre, postsamling holder databasesamlingen. Spesielt, c. BindJSON("post") er en JSONified modellforekomst som kaller hvert modellfelt som postPayload; dette går inn i databasen.

Hvordan lage GET-endepunktet

GET-endepunktet, i routes/read.go, leser et enkelt dokument fra databasen via sin unike ID. Det starter også med å importere tilpassede og tredjepartspakker:

pakke ruter
import (
	getsamling "CRUD_API/samling"
	database "CRUD_API/databaser"
	modell "CRUD_API/modell"
"kontekst"
"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. Kontekst){
	ctx, avbryt := kontekst. WithTimeout (kontekst. Bakgrunn(), 10*tid. Sekund)
var DB = database. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Innlegg")


postId := c. Param("postId")
var resultatmodell. Innlegg


utsett avbryt()


objId, _ := primitiv. ObjectIDFromHex (postId)


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


res := kart[streng]grensesnitt{}{"data": resultat}


hvis feil != null {
 c. JSON(http. StatusInternalServerError, gin. H{"beskjed": feil})
komme tilbake
	}
c. JSON(http. StatusCreated, gin. H{"beskjed": "suksess!", "Data": res})
}

De postId variabel er en parametererklæring. Den får et dokuments objekt-ID som objId.

Men, resultat er en forekomst av databasemodellen, som senere holder det returnerte dokumentet som res.

Hvordan lage PUT-endepunktet

PUT-behandleren, i routes/update.go, ligner POST-behandleren. Denne gangen oppdaterer den et eksisterende innlegg med sin unike objekt-ID:

pakke ruter
import (
	getsamling "CRUD_API/samling"
	database "CRUD_API/databaser"
	modell "CRUD_API/modell"
"kontekst"
"net/http"
"tid"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func Oppdater Post(c *gin. Kontekst){
	ctx, avbryt := kontekst. WithTimeout (kontekst. Bakgrunn(), 10 * tid. Sekund)
var DB = database. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Innlegg")


postId := c. Param("postId")
var stolpemodell. Innlegg


utsett avbryt()


objId, _ := primitiv. ObjectIDFromHex (postId)


hvis feil := c. BindJSON(&post); feil != null {
 c. JSON(http. StatusInternalServerError, gin. H{"beskjed": feil})
komme tilbake
	}


redigert := bson. M{"tittel": post. Tittel, "artikkel": post. Artikkel}


resultat, feil := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$sett": redigert})


res := kart[streng]grensesnitt{}{"data": resultat}


hvis feil != null {
 c. JSON(http. StatusInternalServerError, gin. H{"beskjed": feil})
komme tilbake
	}


hvis resultatet. MatchedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"beskjed": "Data gjør det't eksisterer"})
komme tilbake
	}
c. JSON(http. StatusCreated, gin. H{"beskjed": "data ble oppdatert!", "Data": res})
}

Et JSON-format for modellforekomsten (post) kaller opp hvert modellfelt fra databasen. Resultatvariabelen bruker MongoDB $sett operatør for å oppdatere et nødvendig dokument kalt av objekt-ID.

De resultat. MatchedCount betingelse forhindrer at koden kjøres hvis det ikke er noen oppføring i databasen eller den beståtte IDen er ugyldig.

Opprette et DELETE-endepunkt

SLETT-endepunktet, i delete.go, fjerner et dokument basert på objekt-ID-en som er sendt som en URL-parameter:

pakke ruter
import (
	getsamling "CRUD_API/samling"
	database "CRUD_API/databaser"
"kontekst"
"net/http"
"tid"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func Slett innlegg(c *gin. Kontekst){
	ctx, avbryt := kontekst. WithTimeout (kontekst. Bakgrunn(), 10*tid. Sekund)
var DB = database. ConnectDB()
	postId := c. Param("postId")


var postCollection = getcollection. GetCollection (DB, "Innlegg") 
	utsett avbryt()
	objId, _ := primitiv. ObjectIDFromHex (postId) 
	resultat, feil := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := kart[streng]grensesnitt{}{"data": resultat}


hvis feil != null {
 c. JSON(http. StatusInternalServerError, gin. H{"beskjed": feil})
komme tilbake
	}


hvis resultatet. DeletedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"beskjed": "Ingen data å slette"})
komme tilbake
	}
c. JSON(http. StatusCreated, gin. H{"beskjed": "Artikkelen ble slettet", "Data": res})
}

Denne koden sletter en post ved å bruke DeleteOne funksjon. Den bruker også resultat. DeletedCount egenskap for å forhindre at koden kjøres hvis databasen er tom eller objekt-ID-en er ugyldig.

Opprett API Runner-filen

Til slutt oppretter du en main.go inne i prosjektets rotkatalog. Den endelige prosjektstrukturen din skal se slik ut:

Denne filen håndterer ruterkjøring for hvert endepunkt:

pakke hoved-
import (
 ruter "CRUD_API/ruter"
"github.com/gin-gonic/gin"
)


func hoved-(){
 ruter := gin.Misligholde()


ruter. POST("/", ruter. Opprett innlegg)


// kalt som localhost: 3000/getOne/{id}
 ruter. FÅ("getOne/:postId", ruter. ReadOnePost)


// kalt som lokal vert: 3000/Oppdater/{id}
 ruter. SETTE("/update/:postId", ruter. UpdatePost)


// kalt som lokal vert: 3000/slette/{id}
 ruter. SLETT("/slette/:postId", ruter. Slett innlegg)
ruter. Løpe("lokal vert: 3000")
}

Denne filen er hovedpakken som kjører andre filer. Det starter med å importere rutebehandlerne. Neste er ruter variabel, en gin instans som fremkaller HTTP-handlingene og kaller hvert endepunkt ved funksjonsnavnet fra ruter pakke.

CRUD-prosjektet ditt fortsetter lokal vert: 3000. For å kjøre serveren og test CRUD API, kjør følgende kommando i basiskatalogen din:

gåløpehoved-.gå

Gjør Golang CRUD-prosjektet ditt til et brukbart produkt

Du har opprettet en CRUD API med Go; Gratulerer! Selv om dette er et mindre prosjekt, har du sett hva som kreves for å utføre vanlige HTTP-forespørsler i Go.

Du kan bli mer kreativ ved å utvide dette til en mer praktisk applikasjon som gir verdi til brukerne. Go er et egnet programmeringsspråk for en rekke brukstilfeller.