Come collegare MongoDB con Golang

Proprio come la lingua C, la lingua Golang è anche una lingua open source che può essere eseguita su molti strumenti sui sistemi Windows e Linux/Unix per creare record. Come C ++ e Java, possiamo stabilire una connessione tra un sistema client MongoDB e andare in linguaggio utilizzando qualsiasi strumento Golang. Per fare ciò, eseguiremo diversi passaggi molto importanti e necessari in Ubuntu 22.04 Utilizzando lo strumento di codice Visual Studio per un programma. Prima di stabilire una connessione con la bussola MongoDB, tendiamo a installare MongoDB e Visual Studio Code insieme a "GO" e richieste estensioni nella guida per aiutarti nel linguaggio Go.

Installa MongoDB

Abbiamo scaricato il pacchetto "Deb" del server MongoDB dal suo sito Web ufficiale. Il pacchetto "Deb" può anche essere eseguito in Ubuntu usando lo strumento di comando "DPKG" sul terminale.

Eseguito il file del server MongoDB sul terminale con i diritti di "sudo" e fornito un passcode.

saeedraza@virtualbox: ~ $ sudo dpkg -i Mongodb-Org-Server_6.0.3_amd64.Deb

Se hai trovato il servizio MongoDB inattivo alla fine dopo aver provato l'istruzione "SystemCtl" di Ubuntu per verificare lo stato, puoi aggiornarlo anche. Per attivare MongoDB, prova l'istruzione SystemCtl con le parole chiave "Start" e "Abilita".

saeedraza@virtualbox: ~ $ sudo systemctl start mongod
saeedraza@virtualbox: ~ $ sudo systemctl abilita mongod
saeedraza@virtualbox: ~ $ sudo systemctl status Mongod

Lancia MongoDB

Dopo l'installazione, avvia rapidamente la shell MongoDB utilizzando la query "Mongo". Passa al database "amministratore" per eseguire i passaggi del procedimento.

saeedraza@virtualbox: ~ $ mongo
Mongodb Shell Version V5.0.14
Connessione a: MongoDB: // 127.0.0.1: 27017/?compressori = disabili e gssapiservicename = MongoDB
Sessione implicita: sessione "id": uuid ("34cc8e0f-b6b0-4191-adadea-676411f66cf5")
Versione del server MongoDB: 6.0.3

Stiamo creando un nuovo utente con i diritti di amministrazione utilizzando la funzione CreateUser ().

> Usa l'amministratore
Passato a DB Admin
> db.creare un utente(
...
... Utente: "Saeed",
... PWD: "12345",
... Ruoli: [Role: "UserAdminyDatabase", DB: "Admin", "ReadWriteanyDatabase"]
...)
Utente aggiunto correttamente:
"Utente": "Saeed",
"Ruoli": [

"Ruolo": "UserAdminanyDatabase",
"db": "amministratore"
,
"ReadWriteanyDatabase"
"

Autorizzato l'utente "SAEED" utilizzando le credenziali nella funzione "Auth" e visualizzato i database attualmente di proprietà di MongoDB.

> db.Auth ('Saeed', '12345')
1
> Mostra dbs
amministratore 0.000 GB
config 0.000 GB
locale 0.000 GB

Installa il driver MongoDB per Golang

Apri il terminale nel codice Visual Studio e spostati all'interno della cartella "Golang" in cui si desidera aggiungere i file del codice sorgente. Esegui l'istruzione "Go mod init" con il nome della cartella per creare un "Go.file mod ". Carica il driver MongoDB per la lingua Go tramite la query "Go Get".

saeedraza@virtualbox: ~/golang $ go mod init golang

In alcuni casi, è necessario caricare anche il driver MongoDB in formato BSON per Golang.

saeedraza@virtualbox: ~/golang $ go go go go.MongodB.org/mongo-driver/bson

Assicurati di aggiungere i pacchetti di estensione necessari come "GOPLS" nel codice Visual Studio utilizzando il pannello Extensions senza utilizzare alcuna istruzione.

Insieme a "Gopls", il Golang potrebbe richiedere di installare lo strumento "DLV".

Esempio di codice Golang

Il file di codice “Main.Go ”è stato avviato con l'importazione di alcuni pacchetti utili verranno utilizzati nell'intero codice per la connessione. Un totale di 7 importazioni sono state fatte qui. Dopo aver importato i pacchetti, abbiamo creato una nuova struttura denominata Mongofield con 4 membri di dati di tipo JSON in esso. 2 di questi membri dei dati sono stringhe e 2 di essi sono numeri interi.

Successivamente, un tipo costante di "URI" variabile è stato dichiarato con un indirizzo client o devi aggiungere il tuo indirizzo locale in esso in base al nome utente e alla password. Le funzioni principali () iniziano con l'uso della funzione Connect () di Golang per connettersi con MongoDB tramite un oggetto "mongo". La funzione Applicuri () prenderà la variabile "URI" come argomento da applicare sulla funzione client () in modo che una connessione possa essere stabilita tramite un indirizzo host. Il pacchetto di contesto ha svolto il ruolo principale per chiamare la funzione todo () per richiedere una connessione. Se la connessione è stata stabilita tra il codice Visual Studio e il MongoDB correttamente, il segnale restituito client verrà aggiunto alla variabile "client"; Altrimenti, l'errore verrà archiviato nella variabile "err".

L'istruzione "if" è qui per visualizzare i messaggi di conseguenza. Se la variabile "err" ha ottenuto un valore diverso da "nullo", la funzione println () dal pacchetto formato "fmt" verrà stampato tale errore nella schermata di output, il terminale. Il pacchetto "OS" verrà utilizzato per uscire dal programma se si verifica l'errore. Il pacchetto di contesto viene nuovamente utilizzato qui per gestire il timeout per stabilire la connessione attraverso questo programma. Per il particolare valore di timeout "CTX", il nostro programma sarà eseguito. Una nuova collezione "Person" insieme a un nuovo database "Nuovo" verrà creata nel client MongoDB tramite Golang. Println () visualizzerà il tipo di raccolta "C" utilizzando la funzione "typeof" dal pacchetto riflette.

Un record "Rec" è stato creato utilizzando la struttura Mongofield Data Membro che vengono inizializzati qui uno ad uno. Il tipo di record è stato visualizzato e il record "Rec" verrà inserito in client MongoDB utilizzando la funzione insertOne con l'oggetto di raccolta "C". L'inserimento riuscito porta a una variabile "risultato" con il valore di successo mentre la variabile "inserterr" manterrà il valore di errore. L'istruzione "if" viene nuovamente utilizzata per verificare e visualizzare l'errore nell'inserimento di un record solo se la variabile "Inserterr" vale diversa dal valore "zero". Altrimenti, la parte "else" della dichiarazione terrà alcune dichiarazioni println () per visualizzare il tipo di record da inserire, l'ID record e il messaggio di successo per la connessione e l'inserimento che ha avuto luogo. Il codice Golang è ora completo.

Pacchetto principale
importazione (
"contesto"
"FMT"
"OS"
"riflettere"
"tempo"
"andare.MongodB.Org/Mongo-Driver/Mongo "
"andare.MongodB.Org/Mongo-Driver/Mongo/Opzioni "
)
tipo Mongofield struct
Nome String 'Json: "Field STR"'
Email String 'JSON: "Field STR"'
Age int 'json: "field int"'
Stipendio int 'json: "field int"'

const Uri = “MongoDB: // Utente: password@localhost: 27017/?maxpoolsize = 20 & w = maggioranza "
func main ()
Client, err: = Mongo.Connetti (contesto.Todo (), opzioni.Cliente().Applicuri (URI))
Se err != nil
fmt.Println ("Mongo.Connect () Errore: ", err)
sistema operativo.Uscita (1)

CTX, _: = contesto.Withtimeout (contesto.Background (), 15*Tempo.Secondo)
c: = client.Database ("nuovo").Collezione ("persona")
fmt.Println ("Tipo di collezione:", riflette.Typeof (c), "\ n")
Rec: = Mongofield
Nome: "Eden",
Email: "[email protected] ",
Età: 45,
Stipendio: 50000
fmt.Println ("tipo di record:", riflette.Typeof (rec), "\ n")
risultato, inserterr: = c.Insertone (CTX, REC)
Se inserterr != nil
fmt.Println ("Errore insertone:", inserterr)
sistema operativo.Uscita (1)
altro
fmt.Println ("Tipo di risultato insertone:", riflette.Typeof (risultato))
newid = risultato.Inserita
fmt.Println ("ID record inserito:", newid))
fmt.Println ("record collegati e inseriti correttamente!")

Salva il codice Golang e apri il terminale all'interno della cartella Golang. Ora, usa l'istruzione "Go" con la parola chiave "Esegui" per eseguire il "Main.File di codice GO ". Il debug ha avuto successo e la raccolta "persona" è stata generata con successo nel mongodb. L'output mostra il tipo di raccolta, il tipo di record, il tipo di risultato e il "ID" di un record.

saeedraza@virtualbox: ~/golang $ go run main.andare
Tipo di raccolta: *Mongo.Collezione
Tipo di record: principale.Mongofield
Tipo di risultato insertone: *Mongo.Insertonesult
ID record inserito: ObjectID ("63A8535AC97B4218230664B6")
Record collegati e inseriti correttamente.

Apri la bussola "MongoDB" alla fine e connettiti con il suo host locale usando "URI".

Dopo essersi trasferiti all'interno del database "nuovo", abbiamo visualizzato la raccolta "persona" nella sezione "documenti" insieme al record che abbiamo aggiunto.

Conclusione

Questa guida illustra l'uso del linguaggio GO per aggiungere record nel client MongoDB utilizzando uno strumento di codice Visual Studio nel sistema Linux. Per questo, abbiamo installato MongoDB insieme al driver MongoDB per "Golang" nel sistema. Usando un linguaggio Golang, abbiamo creato un file "go" in MongoDB e abbiamo discusso della varietà di pacchetti e funzioni di Golang per creare una connessione a MongoDB e inserire i record. Alla fine, abbiamo dimostrato i risultati sulla bussola mongodb che dimostra che è possibile collegare qualsiasi strumento Golang a MongoDB.