Jak stworzyć CRUD API z Golang's Gin i MongoDB

Jak stworzyć CRUD API z Golang's Gin i MongoDB

Golang jest jednym z najlepiej płatnych, pożądanych języków programowania z wieloma aplikacjami. W połączeniu z frameworkami, takimi jak Gin, Revel i gorilla/mux, możesz łatwo utworzyć API za pomocą Go.





Dowiedz się, jak stworzyć CRUD API w Golangu przy użyciu frameworka Gin HTTP.



MAKEUSEOF WIDEO DNIA

Wstępna konfiguracja i instalacja

Zacznij korzystać z Golang instalując go na swoim komputerze, jeśli jeszcze tego nie zrobiłeś.





Po zainstalowaniu następnym krokiem jest utworzenie folderu głównego projektu na komputerze i zainicjowanie modułu Go w tym katalogu głównym.

Aby to zrobić, otwórz CLI , przejdź do folderu głównego projektu i uruchom:



go mod init module_name

Zobaczysz nazwę swojego modułu (np. CRUD_API ) i jego wersję po otwarciu go.mod plik. Wszystkie niestandardowe pakiety będą pochodzić z tego modułu nadrzędnego. Tak więc każdy importowany pakiet niestandardowy przyjmuje postać:

import(package CRUD_API/package-directory-name)

Następnie zainstaluj pakiety niezbędne do stworzenia CRUD API. W takim przypadku użyj Gin Gonic do trasowania punktów końcowych API:



go get github.com/gin-gonic/gin

Teraz zainstaluj sterownik MongoDB do przechowywania danych:

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

Jak się połączyć Przejdź do MongoDB

Wszystko, czego potrzebujesz, to Twój MongoDB URI, aby połączyć Golanga z bazą danych. Zwykle wygląda to tak, jeśli łączysz się lokalnie z MongoDB Atlas:



jak się dowiedzieć, kiedy utworzyłeś swoje konto google 
Mongo_URL = "mongodb://127.0.0.1:27017"

Teraz utwórz nowy folder w katalogu głównym projektu i nazwij go bazy danych . Utwórz plik Go w tym folderze i nazwij go baza.go .

To jest twój pakiet bazy danych, który zaczyna się od zaimportowania wymaganych bibliotek:

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 
}

Najlepszą praktyką jest ukrycie zmiennych środowiskowych, takich jak ciąg połączenia z bazą danych w .env plik korzystanie z pakietu dotenv . Dzięki temu Twój kod jest bardziej przenośny i przydaje się podczas korzystania z Instancja klastra w chmurze MongoDB , na przykład.

The ConnectDB funkcja nawiązuje połączenie i zwraca nowy obiekt MongoDB Client.

Utwórz kolekcję bazy danych

MongoDB przechowuje dane w kolekcjach, które zapewniają interfejs do danych bazowych.

Aby obsłużyć funkcję pobierania kolekcji, zacznij od utworzenia nowego folderu, Kolekcja , w katalogu głównym projektu. Teraz utwórz nowy plik Go, getCollection.go , który pobiera kolekcję z bazy danych:

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 
}

Ta funkcja pobiera kolekcję z bazy danych MongoDB. W tym przypadku nazwa bazy danych to myGoappDB , z Posty jako jego kolekcję.

Utwórz model bazy danych

Utwórz nowy folder w katalogu głównym i wywołaj go Model . Ten folder obsługuje model bazy danych.

Utwórz nowy plik Go w tym folderze i nazwij go model.go . Twój model, w tym przypadku, to post na blogu o tytule:

jak znaleźć adres IP mojego telefonu z Androidem? 
package model 
  
import ( 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
type Post struct { 
	ID      primitive.ObjectID 
	Title   string 
	Article string 
}

Tworzenie API CRUD z Go

Następnym krokiem jest stworzenie CRUD API. Aby rozpocząć od tej sekcji, utwórz nowy folder w katalogu głównym projektu do obsługi punktów końcowych. Nazwać trasy .

Utwórz osobny plik Go w tym folderze dla każdej akcji. Na przykład możesz je nazwać utwórz.go , przeczytaj.go , aktualizacja.go , oraz usuń.go . Wyeksportujesz te programy obsługi jako trasy pakiet.

Jak utworzyć punkt końcowy POST w Go

Zacznij od zdefiniowania punktu końcowego POST do zapisywania danych w bazie danych.

W środku trasy/utwórz.go , dodaj następujące:

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

Ten kod rozpoczyna się od zaimportowania niestandardowych modułów projektu. Następnie importuje pakiety innych firm, w tym Gin oraz Sterownik MongoDB .

Dalej, postKolekcja przechowuje kolekcję bazy danych. Szczególnie, c.BindJSON('post') jest instancją modelu JSONified, która wywołuje każde pole modelu jako postPayload ; trafia do bazy danych.

Jak utworzyć punkt końcowy GET

Punkt końcowy GET, w trasy/read.go , odczytuje pojedynczy dokument z bazy danych za pomocą swojego unikalnego identyfikatora. Rozpoczyna się również od importu pakietów niestandardowych i innych firm:

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 posty zmienna jest deklaracją parametru. Pobiera identyfikator obiektu dokumentu jako identyfikator obiektu .

Jednakże, wynik jest instancją modelu bazy danych, która później przechowuje zwrócony dokument jako res .

Jak utworzyć punkt końcowy PUT

Program obsługi PUT, w trasy/update.go , jest podobny do procedury obsługi POST. Tym razem aktualizuje istniejący post o unikalny identyfikator obiektu:

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

Format JSON instancji modelu ( Poczta ) wywołuje każdą zmienną modelu z bazy danych. Zmienna wynikowa używa MongoDB $zestaw operatora, aby zaktualizować wymagany dokument wywoływany przez jego identyfikator obiektu.

The wynik.MatchedCount warunek uniemożliwia uruchomienie kodu, jeśli nie ma rekordu w bazie danych lub przekazany identyfikator jest nieprawidłowy.

Tworzenie DELETE Endpoint

Punkt końcowy DELETE, w usuń.go , usuwa dokument na podstawie identyfikatora obiektu przekazanego jako parametr adresu URL:

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

Ten kod usuwa rekord za pomocą Usuńjeden funkcjonować. Wykorzystuje również wynik.DeletedCount właściwość, aby zapobiec uruchomieniu kodu, jeśli baza danych jest pusta lub identyfikator obiektu jest nieprawidłowy.

Utwórz plik programu uruchamiającego API

Na koniec utwórz main.go wewnątrz katalogu głównego projektu. Twoja ostateczna struktura projektu powinna wyglądać tak:

Struktura projektu Golang CRUD

Ten plik obsługuje wykonanie routera dla każdego punktu końcowego:

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

Ten plik jest głównym pakietem, który uruchamia inne pliki. Zaczyna się od zaimportowania programów obsługi tras. Dalej jest router zmienna, a Gin instancja, która wywołuje akcje HTTP i wywołuje każdy punkt końcowy przez nazwę funkcji z trasy pakiet.

Twój projekt CRUD działa Lokalny Gospodarz: 3000 . Aby uruchomić serwer i przetestuj CRUD API , uruchom następujące polecenie w swoim katalogu podstawowym:

jak zrobić nowy adres e-mail 
go run main.go

Zmień swój projekt Golang CRUD w użyteczny produkt

Pomyślnie utworzyłeś CRUD API za pomocą Go; Gratulacje! Chociaż jest to niewielki projekt, widziałeś już, jak wykonać zwykłe żądania HTTP w Go.

Możesz zwiększyć swoją kreatywność, rozszerzając to na bardziej praktyczną aplikację, która zapewnia użytkownikom wartość. Go to odpowiedni język programowania dla wielu przypadków użycia.