Golang er et af de bedst betalende, efterspurgte programmeringssprog med mange applikationer. Når du er parret med rammer som Gin, Revel og gorilla/mux, kan du nemt oprette en API med Go.

Lær, hvordan du opretter en CRUD API i Golang ved hjælp af Gin HTTP-rammeværket.

Indledende opsætning og installation

Kom godt i gang med Golang ved at installere det på din computer, hvis du ikke allerede har gjort det.

Når det er installeret, er næste trin at oprette en projektrodmappe på din maskine og initialisere et Go-modul i den rodmappe.

For at gøre dette skal du åbne en CLI, naviger til din projektrodmappe og kør:

go mod init modulnavn

Du vil se dit modulnavn (f.eks. CRUD_API) og dens version, når du åbner go.mod fil. Alle tilpassede pakker kommer fra dette overordnede modul. Så enhver importeret tilpasset pakke har formen:

importere(pakke CRUD_API/pakke-mappenavn)

Installer derefter de nødvendige pakker til at oprette CRUD API. Brug i dette tilfælde Gin Gonic for at dirigere API-endepunkterne:

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

Installer nu MongoDB-driveren for at gemme data:

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

Sådan forbinder du Gå til MongoDB

Alt du behøver er din MongoDB URI for at forbinde Golang med databasen. Det ser typisk sådan ud, hvis du opretter forbindelse til MongoDB Atlas lokalt:

Mongo_URL = "mongodb://127.0.0.1:27017"

Opret nu en ny mappe i dit projekts rodmappe og kald den databaser. Opret en Go-fil i denne mappe, og navngiv den database.go.

Dette er din databasepakke, og den starter med at importere de nødvendige biblioteker:

pakke database
importere (
"sammenhæng"
"fmt"
"log"
"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 (valgmuligheder. Client().ApplyURI(Mongo_URL))


hvis fejl != nul {
log.Fatal(fejl)
	}


ctx, annuller := kontekst. WithTimeout (kontekst. Baggrund(), 10 * tid. Sekund)
	fejl = klient. Tilslut (ctx)
	udskyd annullere()


hvis fejl != nul {
log.Fatal(fejl)
	}
fmt. Println("Forbundet til mongoDB")
Vend tilbage klient
}

Det er bedste praksis at skjule miljøvariabler som databaseforbindelsesstrengen i en .env fil ved hjælp af dotenv-pakken. Dette gør din kode mere bærbar og er praktisk, når du bruger en MongoDB cloud cluster instans, for eksempel.

Det ConnectDB funktionen etablerer en forbindelse og returnerer et nyt MongoDB Client-objekt.

Opret databasesamling

MongoDB gemmer data i samlinger, som giver en grænseflade til de underliggende databasedata.

For at håndtere samlingshentningsfunktionen skal du starte med at oprette en ny mappe, Kollektion, i dit projektrod. Opret nu en ny Go-fil, getCollection.go, der henter samlingen fra databasen:

pakke få indsamling
importere (
"go.mongodb.org/mongo-driver/mongo"
)
funcGetCollection(klient *mongo.Klient, samlingsnavnsnor) *mongo.Kollektion {
	samling := klient. Database("myGoappDB").Kollektion("Indlæg")
Vend tilbage kollektion
}

Denne funktion henter samlingen fra MongoDB-databasen. Databasenavnet er i dette tilfælde myGoappDB, med Indlæg som sin samling.

Opret databasemodellen

Lav en ny mappe inde i din rodmappe og kald den model. Denne mappe håndterer din databasemodel.

Opret en ny Go-fil i den mappe, og kald den model.go. Din model er i dette tilfælde et blogindlæg med titlen:

pakke model
importere (
"go.mongodb.org/mongo-driver/bson/primitive"
)
type Post struct {
IDprimitiv.ObjectID
	Titelstreng
	Artikelstreng
}

Oprettelse af en CRUD API med Go

Næste op er oprettelsen af ​​CRUD API. For at starte med denne sektion skal du lave en ny mappe i dit projekts rodbibliotek til at håndtere dine slutpunkter. Kald det ruter.

Opret en separat Go-fil i denne mappe for hver handling. For eksempel kan du navngive dem create.go, læs.gå, update.go, og delete.go. Du eksporterer disse behandlere som ruter pakke.

Sådan opretter du POST-endepunktet i Go

Start med at definere POST-slutpunktet for at skrive data ind i databasen.

Inde routes/create.go, tilføj følgende:

pakke ruter
importere (
	få indsamling "CRUD_API/samling"
	database "CRUD_API/databaser"
	model "CRUD_API/model"
"sammenhæng"
"log"
"net/http"
"tid"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func Opret Post(c *gin. Sammenhæng){
var DB = database. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Indlæg")
	ctx, annuller := kontekst. WithTimeout (kontekst. Baggrund(), 10*tid. Sekund)
	indlæg := ny(model. indlæg)
	udskyd annullere()


hvis fejl := c. BindJSON(&stolpe); fejl != nul {
 c. JSON(http. StatusBadRequest, gin. H{"besked": fejl})
log.Fatal(fejl)
Vend tilbage
	}


postPayload := model. Indlæg{
Id: primitiv.NewObjectID(),
Titel: stolpe.Titel,
Artikel: stolpe.Artikel,
	}


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


hvis fejl != nul {
 c. JSON(http. StatusInternalServerError, gin. H{"besked": fejl})
Vend tilbage
	}
c. JSON(http. StatusCreated, gin. H{"besked": "Sendt med succes", "Data": kort[streng]grænseflade{}{"data": resultat}})
}

Denne kode starter med at importere projektets brugerdefinerede moduler. Det importerer derefter tredjepartspakker, inklusive Gin og MongoDB driver.

Yderligere, postsamling holder databasesamlingen. Især c. BindJSON("post") er en JSONificeret modelforekomst, der kalder hvert modelfelt som postPayload; dette går ind i databasen.

Sådan opretter du GET-slutpunktet

GET-endepunktet, i routes/read.go, læser et enkelt dokument fra databasen via dets unikke ID. Det starter også med at importere brugerdefinerede og tredjepartspakker:

pakke ruter
importere (
	få indsamling "CRUD_API/samling"
	database "CRUD_API/databaser"
	model "CRUD_API/model"
"sammenhæng"
"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. Sammenhæng){
	ctx, annuller := kontekst. WithTimeout (kontekst. Baggrund(), 10*tid. Sekund)
var DB = database. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Indlæg")


postId := c. Param("postId")
var resultatmodel. Indlæg


udskyd annullere()


objId, _ := primitiv. ObjectIDFromHex (postId)


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


res := kort[streng]interface{}{"data": resultat}


hvis fejl != nul {
 c. JSON(http. StatusInternalServerError, gin. H{"besked": fejl})
Vend tilbage
	}
c. JSON(http. StatusCreated, gin. H{"besked": "succes!", "Data": res})
}

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

Imidlertid, resultat er en instans af databasemodellen, som senere holder det returnerede dokument som res.

Sådan opretter du PUT-endepunktet

PUT-handleren, i routes/update.go, ligner POST-handleren. Denne gang opdaterer den et eksisterende indlæg ved dets unikke objekt-id:

pakke ruter
importere (
	få indsamling "CRUD_API/samling"
	database "CRUD_API/databaser"
	model "CRUD_API/model"
"sammenhæng"
"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. Sammenhæng){
	ctx, annuller := kontekst. WithTimeout (kontekst. Baggrund(), 10 * tid. Sekund)
var DB = database. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Indlæg")


postId := c. Param("postId")
var stolpe model. Indlæg


udskyd annullere()


objId, _ := primitiv. ObjectIDFromHex (postId)


hvis fejl := c. BindJSON(&stolpe); fejl != nul {
 c. JSON(http. StatusInternalServerError, gin. H{"besked": fejl})
Vend tilbage
	}


redigeret := bson. M{"titel": indlæg. Titel, "artikel": indlæg. Artikel}


resultat, fejl := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$sæt": redigeret})


res := kort[streng]interface{}{"data": resultat}


hvis fejl != nul {
 c. JSON(http. StatusInternalServerError, gin. H{"besked": fejl})
Vend tilbage
	}


hvis resultat. MatchedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"besked": "Data gør't eksisterer"})
Vend tilbage
	}
c. JSON(http. StatusCreated, gin. H{"besked": "data blev opdateret!", "Data": res})
}

Et JSON-format af modelforekomsten (stolpe) kalder hvert modelfelt fra databasen. Resultatvariablen bruger MongoDB $sæt operatør for at opdatere et påkrævet dokument kaldet af dets objekt-id.

Det resultat. MatchedCount betingelse forhindrer koden i at køre, hvis der ikke er nogen post i databasen, eller det beståede ID er ugyldigt.

Oprettelse af et DELETE-slutpunkt

DELETE-slutpunktet, i delete.go, fjerner et dokument baseret på det objekt-id, der er sendt som en URL-parameter:

pakke ruter
importere (
	få indsamling "CRUD_API/samling"
	database "CRUD_API/databaser"
"sammenhæng"
"net/http"
"tid"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func Slet indlæg(c *gin. Sammenhæng){
	ctx, annuller := kontekst. WithTimeout (kontekst. Baggrund(), 10*tid. Sekund)
var DB = database. ConnectDB()
	postId := c. Param("postId")


var postCollection = getcollection. GetCollection (DB, "Indlæg") 
	udskyd annullere()
	objId, _ := primitiv. ObjectIDFromHex (postId) 
	resultat, fejl := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := kort[streng]interface{}{"data": resultat}


hvis fejl != nul {
 c. JSON(http. StatusInternalServerError, gin. H{"besked": fejl})
Vend tilbage
	}


hvis resultat. DeletedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"besked": "Ingen data at slette"})
Vend tilbage
	}
c. JSON(http. StatusCreated, gin. H{"besked": "Artiklen blev slettet", "Data": res})
}

Denne kode sletter en post ved hjælp af DeleteOne fungere. Den bruger også resultat. DeletedCount egenskab for at forhindre koden i at køre, hvis databasen er tom, eller objekt-id'et er ugyldigt.

Opret API Runner-filen

Til sidst skal du oprette en main.go inde i dit projekts rodmappe. Din endelige projektstruktur skal se sådan ud:

Denne fil håndterer routerkørsel for hvert slutpunkt:

pakke vigtigste
importere (
 ruter "CRUD_API/ruter"
"github.com/gin-gonic/gin"
)


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


router. STOLPE("/", ruter. Opret indlæg)


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


// kaldet som localhost: 3000/opdatering/{id}
 router. SÆTTE("/update/:postId", ruter. UpdatePost)


// kaldet som localhost: 3000/slette/{id}
 router. SLET("/slette/:postId", ruter. Slet indlæg)
router. Løb("lokale vært: 3000")
}

Denne fil er hovedpakken, der kører andre filer. Det starter med at importere rutebehandlerne. Næste er router variabel, en gin instans, der fremkalder HTTP-handlingerne og kalder hvert slutpunkt ved dets funktionsnavn fra ruter pakke.

Dit CRUD-projekt kører videre lokale vært: 3000. For at køre serveren og test CRUD API, kør følgende kommando i din basismappe:

gåløbvigtigste.gå

Gør dit Golang CRUD-projekt til et brugbart produkt

Du har oprettet en CRUD API med Go; Tillykke! Selvom dette er et mindre projekt, har du set, hvad der skal til for at udføre almindelige HTTP-anmodninger i Go.

Du kan blive mere kreativ ved at udvide dette til en mere praktisk applikation, der leverer værdi til brugerne. Go er et velegnet programmeringssprog til en række anvendelsestilfælde.