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.

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:

idź mod init nazwa_modułu

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(pakiet CRUD_API/pakiet-nazwa-katalogu)

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

iść Dostawać github.com/gin-gonic/gin

Teraz zainstaluj sterownik MongoDB do przechowywania danych:

iść Dostawać 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:

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:

pakiet Baza danych
import (
"kontekst"
"fmt"
"dziennik"
"czas"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
funkcjonować ConnectDB() *mongo. Klient {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	klient, błąd := mongo. Nowy Klient (opcje. Client().ApplyURI(Mongo_URL))
jeśli błąd != zero {
dziennik.Fatalny(błądzić)
	}
ctx, anuluj := kontekst. Bez limitu czasu (kontekst. Tło(), 10 * czas. Drugi)
	błąd = klient. Połącz (ctx)
	odroczyć anulowanie ()
jeśli błąd != zero {
dziennik.Fatalny(błądzić)
	}
fmt. Drukujln("Połączono z mongoDB")
zwrócić klient
}

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:

pakiet pobierz kolekcję
import (
"go.mongodb.org/mongo-driver/mongo"
)
funkcjonowaćPobierz kolekcję(klient *mongo.Klient, nazwa kolekcjistrunowy) *mongo.Kolekcja {
	kolekcja := klient. Baza danych("myGoappDB").Kolekcja("Posty")
zwrócić kolekcja
}

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:

pakiet Model
import (
"go.mongodb.org/mongo-driver/bson/primitive"
)
rodzaj Struktura posta {
IDprymitywny.Identyfikator obiektu
	Ciąg tytułu
	Artykuł ciąg
}

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:

pakiet trasy
import (
	pobierz kolekcję "CRUD_API/Kolekcja"
	Baza danych "CRUD_API/bazy danych"
	Model "CRUD_API/model"
"kontekst"
"dziennik"
"sieć/http"
"czas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funkcjonować Utwórz post(c *gin. Kontekst){
var DB = baza danych. PołączDB()
	var postCollection = getcollection. Pobierz kolekcję (DB, "Posty")
	ctx, anuluj := kontekst. Bez limitu czasu (kontekst. Background(), 10*czas. Drugi)
	post := Nowy(Model. Posty)
	odroczyć anulowanie ()
jeśli błąd := c. BindJSON(&Poczta); błąd != zero {
 c. JSON(http. StatusBadRequest, gin. H{"wiadomość": err})
dziennik.Fatalny(błądzić)
zwrócić
	}
postPayload := model. Posty{
ID: prymitywny.Identyfikator NowegoObiektu(),
Tytuł: Poczta.Tytuł,
Artykuł: Poczta.Artykuł,
	}
wynik, błąd := postCollection. InsertOne (ctx, postPayload)
jeśli błąd != zero {
 c. JSON(http. StatusInternalServerError, gin. H{"wiadomość": err})
zwrócić
	}
c. JSON(http. StatusUtworzono, gin. H{"wiadomość": "Opublikowano pomyślnie", "Dane": mapa[ciąg]interfejs{}{"dane": wynik}})
}

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:

pakiet trasy
import (
	pobierz kolekcję "CRUD_API/Kolekcja"
	Baza danych "CRUD_API/bazy danych"
	Model "CRUD_API/model"
"kontekst"
"sieć/http"
"czas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funkcjonować Przeczytaj jeden post(c *gin. Kontekst){
	ctx, anuluj := kontekst. Bez limitu czasu (kontekst. Background(), 10*czas. Drugi)
var DB = baza danych. PołączDB()
	var postCollection = getcollection. Pobierz kolekcję (DB, "Posty")
postId := c. Param("postId")
var model wynikowy. Posty
odroczyć anulowanie ()
objId, _ := prymitywny. ObjectIDFromHex (postId)
błąd := postCollection. FindOne (ctx, bson. M{"ID": objId}).Decode(&wynik)
res := mapa[napis]interfejs{}{"dane": wynik}
jeśli błąd != zero {
 c. JSON(http. StatusInternalServerError, gin. H{"wiadomość": err})
zwrócić
	}
c. JSON(http. StatusUtworzono, gin. H{"wiadomość": "powodzenie!", "Dane": res})
}

The postId 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:

pakiet trasy
import (
	pobierz kolekcję "CRUD_API/Kolekcja"
	Baza danych "CRUD_API/bazy danych"
	Model "CRUD_API/model"
"kontekst"
"sieć/http"
"czas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funkcjonować Aktualizuj post(c *gin. Kontekst){
	ctx, anuluj := kontekst. Bez limitu czasu (kontekst. Tło(), 10 * czas. Drugi)
var DB = baza danych. PołączDB()
	var postCollection = getcollection. Pobierz kolekcję (DB, "Posty")
postId := c. Param("postId")
var post model. Posty
odroczyć anulowanie ()
objId, _ := prymitywny. ObjectIDFromHex (postId)
jeśli błąd := c. BindJSON(&Poczta); błąd != zero {
 c. JSON(http. StatusInternalServerError, gin. H{"wiadomość": err})
zwrócić
	}
edytowane := bson. M{"tytuł": Poczta. Tytuł, "artykuł": Poczta. Artykuł}
wynik, błąd := postCollection. UpdateOne (ctx, bson. M{"ID": objId}, bson. M{"$zestaw": edytowano})
res := mapa[napis]interfejs{}{"dane": wynik}
jeśli błąd != zero {
 c. JSON(http. StatusInternalServerError, gin. H{"wiadomość": err})
zwrócić
	}
jeśli wynik. Dopasowana liczba < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"wiadomość": "Dane nie'nie istnieje"})
zwrócić
	}
c. JSON(http. StatusUtworzono, gin. H{"wiadomość": "dane zostały zaktualizowane pomyślnie!", "Dane": 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. Dopasowana liczba 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:

pakiet trasy
import (
	pobierz kolekcję "CRUD_API/Kolekcja"
	Baza danych "CRUD_API/bazy danych"
"kontekst"
"sieć/http"
"czas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funkcjonować Usuń post(c *gin. Kontekst){
	ctx, anuluj := kontekst. Bez limitu czasu (kontekst. Background(), 10*czas. Drugi)
var DB = baza danych. PołączDB()
	postId := c. Param("postId")
var postCollection = getcollection. Pobierz kolekcję (DB, "Posty") 
	odroczyć anulowanie ()
	objId, _ := prymitywny. ObjectIDFromHex (postId) 
	wynik, błąd := postCollection. DeleteOne (ctx, bson. M{"ID": identyfikator obiektu}) 
	res := mapa[napis]interfejs{}{"dane": wynik}
jeśli błąd != zero {
 c. JSON(http. StatusInternalServerError, gin. H{"wiadomość": err})
zwrócić
	}
jeśli wynik. Liczba usuniętych < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"wiadomość": "Brak danych do usunięcia"})
zwrócić
	}
c. JSON(http. StatusUtworzono, gin. H{"wiadomość": "Artykuł został pomyślnie usunięty", "Dane": res})
}

Ten kod usuwa rekord za pomocą Usuńjeden funkcjonować. Wykorzystuje również wynik. Liczba usuniętych 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:

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

pakiet Główny
import (
 trasy "CRUD_API/trasy"
"github.com/gin-gonic/gin"
)
funkcjonować Główny(){
 router := gin.Domyślna()
router. POCZTA("/", trasy. Utwórz posta)
// nazwane jako localhost: 3000/getOne/{id}
 router. DOSTAWAĆ("getOne/:postId", trasy. Przeczytaj OnePost)
// nazwany jako localhost: 3000/aktualizacja/{ID}
 router. POŁOŻYĆ("/update/:postId", trasy. AktualizujPost)
// nazwany jako localhost: 3000/kasować/{ID}
 router. KASOWAĆ("/kasować/:postId", trasy. Usuń post)
router. Biegać("Lokalny Gospodarz: 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:

iśćbiegaćGłówny.iść

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.