Golang je jedan od najplaćenijih i traženih programskih jezika s mnogo aplikacija. U kombinaciji s okvirima kao što su Gin, Revel i gorilla/mux, možete jednostavno izraditi API s Go-om.
Naučite kako stvoriti CRUD API u Golangu pomoću Gin HTTP okvira.
MAKEUSEOF VIDEO DANA
Početno postavljanje i instalacija
Započnite s Golangom tako da ga instalirate na svoje računalo ako to već niste učinili.
Nakon instalacije, sljedeći korak je stvaranje korijenske mape projekta na vašem računalu i inicijalizacija Go modula u tom korijenskom direktoriju.
Da biste to učinili, otvorite a CLI , dođite do korijenske mape projekta i pokrenite:
go mod init module_name
Vidjet ćete naziv svog modula (npr. CRUD_API ) i njegovu verziju kada otvorite go.mod datoteka. Svi prilagođeni paketi dolazit će iz ovog nadređenog modula. Dakle, svaki uvezeni prilagođeni paket ima oblik:
import(package CRUD_API/package-directory-name)
Zatim instalirajte pakete potrebne za stvaranje CRUD API-ja. U ovom slučaju, koristite Gin Gonic za usmjeravanje API krajnjih točaka:
go get github.com/gin-gonic/gin
Sada instalirajte MongoDB Driver za pohranu podataka:
go get go.mongodb.org/mongo-driver/mongo
Kako se povezati Idite na MongoDB
Sve što trebate je vaš MongoDB URI za povezivanje Golanga s bazom podataka. Obično izgleda ovako ako se povezujete na MongoDB Atlas lokalno:
Mongo_URL = "mongodb://127.0.0.1:27017"
Sada stvorite novu mapu u korijenskom direktoriju vašeg projekta i pozovite je baze podataka . Stvorite Go datoteku unutar ove mape i dajte joj naziv baza podataka.go .
Ovo je vaš paket baze podataka i počinje uvozom potrebnih biblioteka:
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
}
Najbolja je praksa sakriti varijable okruženja poput niza povezivanja baze podataka u a .env datoteka pomoću paketa dotenv . To čini vaš kod prenosivijim i korisnim kada koristite a Instanca MongoDB klastera u oblaku , na primjer.
The ConnectDB funkcija uspostavlja vezu i vraća novi objekt MongoDB klijenta.
Stvorite zbirku baze podataka
MongoDB pohranjuje podatke u zbirkama, koje pružaju sučelje za temeljne podatke baze podataka.
Za rukovanje funkcijom dohvaćanja zbirke, počnite stvaranjem nove mape, Kolekcija , u korijenu vašeg projekta. Sada izradite novu Go datoteku, getCollection.go , koji dobiva kolekciju iz baze podataka:
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
}
Ova funkcija dobiva kolekciju iz MongoDB baze podataka. Naziv baze podataka, u ovom slučaju, je myGoappDB , sa Postovi kao svoju zbirku.
Stvorite model baze podataka
Napravite novu mapu unutar svog korijenskog direktorija i pozovite je model . Ova mapa upravlja vašim modelom baze podataka.
Stvorite novu Go datoteku unutar te mape i pozovite je model.ići . Vaš je model, u ovom slučaju, post na blogu s naslovom:
package model
import (
"go.mongodb.org/mongo-driver/bson/primitive"
)
type Post struct {
ID primitive.ObjectID
Title string
Article string
}
Stvaranje CRUD API-ja uz Go
Sljedeće je stvaranje CRUD API-ja. Da biste započeli s ovim odjeljkom, napravite novu mapu unutar korijenskog direktorija vašeg projekta za rukovanje krajnjim točkama. Nazovi to rute .
Stvorite zasebnu Go datoteku u ovoj mapi za svaku radnju. Na primjer, možete ih imenovati stvoriti.krenuti , čitati.ići , ažuriraj.kreni , i izbrisati.krenuti . Ove rukovatelje ćete izvesti kao rute paket.
Kako stvoriti krajnju točku POST-a u Go
Započnite definiranjem POST krajnje točke za upisivanje podataka u bazu podataka.
Unutra rute/create.go , dodajte sljedeće:
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}})
}
Ovaj kôd počinje uvozom prilagođenih modula projekta. Zatim uvozi pakete trećih strana uključujući Džin i MongoDB upravljački program .
Unaprijediti, postCollection čuva zbirku baze podataka. Posebno, c.BindJSON('post') je JSONificirana instanca modela koja poziva svako polje modela kao postPayload ; ovo ide u bazu podataka.
Kako stvoriti GET krajnju točku
GET krajnja točka, u rute/read.go , čita jedan dokument iz baze podataka preko njegovog jedinstvenog ID-a. Također počinje uvozom prilagođenih paketa i paketa trećih strana:
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 postovi varijabla je deklaracija parametra. Dobiva ID objekta dokumenta kao objId .
Međutim, proizlaziti je instanca modela baze podataka, koja kasnije čuva vraćeni dokument kao res .
Kako stvoriti krajnju točku PUT
Rukovatelj PUT, u rute/ažuriranje.go , sličan je POST rukovatelju. Ovaj put ažurira postojeću objavu svojim jedinstvenim ID-om objekta:
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 format instance modela ( objaviti ) poziva svako polje modela iz baze podataka. Varijabla rezultata koristi MongoDB $set operator za ažuriranje traženog dokumenta koji se poziva njegovim ID-om objekta.
The rezultat.MatchedCount uvjet sprječava izvođenje koda ako u bazi podataka nema zapisa ili je proslijeđeni ID nevažeći.
Stvaranje krajnje točke DELETE
Krajnja točka DELETE, u izbrisati.krenuti , uklanja dokument na temelju ID-a objekta proslijeđenog kao URL parametar:
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})
}
Ovaj kod briše zapis pomoću DeleteOne funkcija. Također koristi rezultat.DeletedCount svojstvo za sprječavanje izvođenja koda ako je baza podataka prazna ili je ID objekta nevažeći.
Stvorite datoteku API Runner
Na kraju, stvorite a glavni.krenuti unutar korijenskog direktorija vašeg projekta. Vaša konačna struktura projekta trebala bi izgledati ovako:
Ova datoteka upravlja izvršavanjem usmjerivača za svaku krajnju točku:
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")
}
Ova datoteka je glavni paket koji pokreće druge datoteke. Započinje uvozom rukovatelja rutama. Sljedeće je ruter varijabla, a džin instanca koja evocira HTTP radnje i poziva svaku krajnju točku prema nazivu funkcije iz rute paket.
Vaš CRUD projekt radi dalje lokalni host: 3000 . Za pokretanje poslužitelja i testirajte CRUD API , pokrenite sljedeću naredbu u svom osnovnom direktoriju:
mogu li baciti na xbox one
go run main.go
Pretvorite svoj Golang CRUD projekt u upotrebljiv proizvod
Uspješno ste izradili CRUD API s Goom; Čestitamo! Iako je ovo manji projekt, vidjeli ste što je potrebno za izvršavanje uobičajenih HTTP zahtjeva u Gou.
Možete postati kreativniji ako ovo proširite na praktičniju aplikaciju koja donosi vrijednost korisnicima. Go je prikladan programski jezik za niz slučajeva upotrebe.