racavedigger.com
Daily insights on Bitcoin and crypto markets
  • Facebook
  • Pinterest
  • Home
  • News

MongoDB supporta Java

Notizia

Iniziare con MongoDB e Java – Crud Operations Tutorial

Puoi impostare il com.MongodB.Proprietà WriteConcern che il MongoTemplate utilizzerà per le operazioni di scrittura se non è stato ancora specificato tramite il driver a un livello superiore come Com.MongodB.Mongo. Se la proprietà WriteConcern di MongoTemplate non viene impostata, sarà impostata su quella set nel DB o l’impostazione della raccolta del driver MongoDB.

Riepilogo

In questo tutorial, esploreremo come iniziare con MongoDB e Java. Copriremo le operazioni di base CRUD (Crea, leggi, aggiorna, eliminano) utilizzando il driver Java di MongoDB e i dati di primavera MongoDB.

Punti chiave:

  1. Il supporto MongoDB per Java include una vasta gamma di funzioni.
  2. Spring fornisce il supporto di configurazione per MongoDB utilizzando classi @Configuration basate su Java o uno spazio dei nomi XML.
  3. La classe Mongotemplate è un’utilità utile per l’esecuzione di operazioni MongoDB comuni e la mappatura degli oggetti tra documenti e pojos.
  4. È supportata la traduzione delle eccezioni nella gerarchia di eccezione di accesso portatili portatili di Spring.
  5. Il servizio di conversione di Spring si integra con la mappatura degli oggetti ricca di funzionalità di MongoDB.
  6. I metadati di mappatura basati sull’annotazione sono disponibili e possono essere estesi per supportare altri formati.
  7. Gli eventi del ciclo di vita della persistenza e della mappatura sono supportati.
  8. Vengono forniti query, criteri e DSL di aggiornamento con sede a Java.
  9. È supportata l’implementazione automatica delle interfacce del repository, inclusi i metodi di ricerca personalizzati.
  10. L’integrazione di querydsl abilita le query di tipo sicuro.
  11. La persistenza cross-store è supportata, consentendo di persistere/recuperare le entità JPA usando MongoDB.
  12. Un appender log log4j è fornito per l’integrazione di MongoDB.
  13. L’integrazione geospaziale è disponibile per lavorare con dati geospaziali.

Domande:

  1. Q1: quali caratteristiche esegue il supporto MongoDB per Java?
  2. A1: il supporto MongoDB per Java include una vasta gamma di funzionalità, come supporto di configurazione a molla, mappatura degli oggetti, traduzione delle eccezioni e altro ancora.

  3. Q2: come possiamo configurare MongoDB in primavera?
  4. A2: MongoDB può essere configurato in primavera utilizzando le classi @Configuration basate su Java o uno spazio dei nomi XML.

  5. Q3: a cosa serve la classe Mongotemplate?
  6. A3: la classe MongotemPlate è una classe helper che aumenta la produttività eseguendo operazioni mongodb comuni e fornendo mappatura degli oggetti tra documenti e pojos.

  7. Q4: In che modo la molla gestisce le eccezioni nelle operazioni MongoDB?
  8. A4: Spring traduce le eccezioni nella sua gerarchia di eccezione di accesso ai dati portatili.

  9. Q5: l’integrazione MongoDB con la mappatura degli oggetti di supporto a molla?
  10. A5: Sì, l’integrazione MongoDB con Spring include la mappatura degli oggetti ricca di funzionalità integrata con il servizio di conversione di Spring.

  11. Q6: MongoDB può supportare altri formati di metadati?
  12. A6: Sì, i metadati di mappatura basati sull’annotazione in MongoDB possono essere estesi per supportare altri formati di metadati.

  13. Q7: MongoDB supporta la persistenza e la mappatura degli eventi del ciclo di vita?
  14. A7: Sì, MongoDB supporta gli eventi del ciclo di vita della persistenza e della mappatura.

  15. Q8: qual è il vantaggio di utilizzare query, criteri e aggiornare le DSL basate su Java in MongoDB?
  16. A8: Criteri, criteri e DSL di aggiornamento basati su Java forniscono un modo più sicuro e conveniente per creare query e aggiornare le operazioni in MongoDB.

  17. Q9: è possibile implementare automaticamente i metodi di ricerca personalizzati nelle interfacce del repository?
  18. A9: Sì, Spring può implementare automaticamente i metodi di ricerca personalizzati nelle interfacce del repository.

  19. Q10: qual è il vantaggio dell’integrazione di querydsl in MongoDB?
  20. A10: l’integrazione di QueryDDSL in MongoDB abilita le query di tipo sicuro.

  21. Q11: può essere utilizzato il mongodb per la persistenza cross-store?
  22. A11: Sì, MongoDB supporta la persistenza cross-store, consentendo di persistere/recuperare le entità JPA usando MongoDB.

  23. Q12: MongoDB fornisce un appender di log log4j?
  24. A12: Sì, MongoDB fornisce un appender log log4j per l’integrazione con log4j.

  25. Q13: MongoDB supporta i dati geospaziali?
  26. A13: Sì, MongoDB fornisce l’integrazione per il lavoro con i dati geospaziali.

Iniziare

Per iniziare con il supporto di MongoDB primaverile, avrai bisogno di MongoDB 1.4 o superiore e Java SE 5 o superiore. Si consiglia di utilizzare l’ultima versione di produzione (2.0.x al momento della scrittura).

Segui questi passaggi per impostare un ambiente di lavoro:

  1. Imposta un server MongoDB in esecuzione. Fare riferimento alla guida di avvio rapido MongoDB per le istruzioni su come avviare un’istanza MongoDB.
  2. Crea un progetto a molla in STS (Spring Tool Suite) o in qualsiasi altro ambiente di sviluppo integrato (IDE).
  3. Includi la dipendenza da MongoDB dei dati primaverili nel POM del progetto.File XML:
  4.         <dipendenza>
                <groupid>org.Springframework.dati</groupid>
                <artifattide>Spring-Data-MongodB</artifattid>
                <versione>1.1.0.PUBBLICAZIONE</versione>
            </dipendenza>
        
  5. Assicurati di avere la versione corretta di Spring specificata nel tuo POM.XML:
  6.         <proprietà>
                <primavera.versione>3.1.2.PUBBLICAZIONE</primavera.versione>
            </proprietà>
        
  7. Aggiungi il repository di traguardi primaverili al tuo pom.XML:
  8.         <repository>
                <repository>
                    <id>Spring-Milestone</id>
                    <nome>Spring Maven Milestone Repository</nome>
                    <URL>http: // Repo.springsource.org/lib-milestone</URL>
                </repository>
            </repository>
        
  9. Imposta il livello di registrazione del log4j su debug nel log4j.Proprietà file:
  10.         log4j.categoria.org.Springframework.dati.documento.MongoDB = debug
            log4j.Appender.stdout.disposizione.Conversionpattern = %d %5p %40.40C:%4L -%m%n
        
  11. Crea una classe di persona semplice per persistere:
  12.         pacchetto org.primavera.MongodB.esempio;
            persona di classe pubblica {
                ID stringa privata;
                Nome stringa privato;
                Età privata int;
                persona pubblica (nome stringa, int age) {
                    Questo.nome = nome;
                    Questo.età = età;
                }
                public String getID () {
                    restituzione ID;
                }
                public String getName () {
                    Nome di ritorno;
                }
                public int getAge () {
                    Età di ritorno;
                }
                @Oltrepassare
                public String toString () {
                    restituire "persona [id =" + id + ", nome =" + nome + ", age =" + age + "]";
                }
            }
        
  13. Crea un’applicazione principale da eseguire:
  14.         pacchetto org.primavera.MongodB.esempio;
            Importa organo statico.Springframework.dati.MongodB.nucleo.Domanda.Criteri.Dove;
            Org di importazione.Apache.Comuni.registrazione.Tronco d'albero;
            Org di importazione.Apache.Comuni.registrazione.Logfactory;
            Org di importazione.Springframework.dati.MongodB.nucleo.Mongooperations;
            Org di importazione.Springframework.dati.MongodB.nucleo.Mongotemplate;
            Org di importazione.Springframework.dati.MongodB.nucleo.Domanda.Domanda;
            Importa com.MongodB.Mongo;
            Classe pubblica Mongoapp {
                log log finale statico privato = logfactory.getlog (Mongoapp.classe);
                public static void main (string [] args) lancia l'eccezione {
                    Mongooperations Mongoops = new MongoTemplate (new Mongo (), "database");
                    Mongoops.inserire (nuovo persona ("Joe", 34));
                    tronco d'albero.Informazioni (Mongoops.FindOne (nuova query (dove ("nome").è ("joe")), persona.classe));
                }
            }
        

Iniziare con MongoDB e Java – Crud Operations Tutorial

Puoi impostare il com.MongodB.Proprietà WriteConcern che il MongoTemplate utilizzerà per le operazioni di scrittura se non è stato ancora specificato tramite il driver a un livello superiore come Com.MongodB.Mongo . Se la proprietà WriteConcern di MongoTemplate non viene impostata, sarà impostata su quella set nel DB o l’impostazione della raccolta del driver MongoDB.

MongoDB supporta Java

Il supporto MongoDB contiene una vasta gamma di funzionalità che sono riassunte di seguito.

  • Supporto di configurazione Spring Utilizzo di classi @Configuration basate su Java o uno spazio dei nomi XML per un’istanza del driver Mongo e set di replica
  • Classe Helper Mongotemplate che aumenta la produttività eseguendo le operazioni di Mongo comuni. Include la mappatura degli oggetti integrati tra documenti e pojos.
  • Traduzione delle eccezioni nella gerarchia delle eccezioni portatili di accesso portatile di Spring
  • Funzionalità di mappatura degli oggetti ricca integrata con il servizio di conversione di Spring
  • Metadati di mappatura basati sull’annotazione ma estensibile per supportare altri formati di metadati
  • Eventi per il ciclo di vita di persistenza e mappatura
  • Query, criteri e aggiornamenti basati su Java
  • Implementatin automatico delle interfacce del repository incluso il supporto per i metodi di ricerca personalizzati.
  • Integrazione di querydsl per supportare le query di tipo-sicuro.
  • Cross -store Persistence – Supporto per le entità JPA con campi persistiti/recuperati trasparente utilizzando MongoDB
  • Log4j log appder
  • Integrazione geospaziale

Per la maggior parte delle attività ti ritroverai a utilizzare Mongotemplate o il supporto del repository che sfruttano entrambi la funzionalità di mappatura ricca. Mongotemplate è il luogo in cui cercare di accedere a funzionalità come contatori incrementali o operazioni CRUD ad hoc. Mongotemplate fornisce anche metodi di callback in modo che sia facile ottenere una presa degli artefatti API di basso livello come ORG.Mongo.Db per comunicare direttamente con mongodb. L’obiettivo con le convenzioni di denominazione su vari artefatti API è copiare quelli nel driver di base di base MongoDB in modo da poter facilmente mappare le tue conoscenze esistenti sulle API di primavera.

5.1 Iniziare

Il supporto di MongoDB primaverile richiede MongoDB 1.4 o superiore e Java SE 5 o superiore. L’ultima versione di produzione (2.0.X come di questa scrittura) si consiglia. Un modo semplice per bootstrap che impostare un ambiente di lavoro è creare un progetto basato a molla in STS.

Per prima cosa è necessario impostare un server MongoDB in esecuzione. Fare riferimento alla guida di avvio rapido MongoDB per una spiegazione su come avviare un’istanza MongoDB. Una volta installato MongoDB iniziale è in genere una questione di esecuzione del seguente comando: Mongo_Home/Bin/Mongod

Per creare un progetto Spring in STS, vai al file -> Nuovo -> Progetto modello Spring -> Progetto Utility Spring Simple -> Premi Sì quando richiesto. Quindi immettere un progetto e un nome di pacchetto come Org.primavera.MongodB.esempio.

Quindi aggiungi quanto segue a pom.Sezione Dipendenze XML.

    org.Springframework.dati Spring-Data-MongodB 1.1.0.PUBBLICAZIONE  

Cambia anche la versione di Spring nel POM.XML per essere

 3.1.2.PUBBLICAZIONE 

Dovrai anche aggiungere la posizione del repository di traguardi primaverili per Maven al tuo POM.XML che è allo stesso livello del tuo elemento

   Spring-Milestone Spring Maven Milestone Repository http: // Repo.springsource.org/lib-milestone  

Il repository è anche sfogliabile qui.

Potresti anche impostare il livello di registrazione su Debug per vedere alcune informazioni aggiuntive, modificare il log4j.Proprietà file da avere

log4j.categoria.org.Springframework.dati.documento.MongoDB = debug log4j.Appender.stdout.disposizione.Conversionpattern = %d %5p %40.40C:%4L -%m%n

Crea una classe di persona semplice per persistere

pacchetto org.primavera.MongodB.esempio; pubblico classe Persona < privato String ID; privato Nome stringa; privato int età; pubblico Persona (nome stringa, int età) < Questo.nome = nome; Questo.età = età; > pubblico String getID () < ritorno id; > pubblico Stringa getName () < ritorno nome; > pubblico int getAge () < ritorno età; > @Oltrepassare pubblico String toString () < ritorno "Person [id hl-string"> ", nome hl-string"> ", age hl-string"> "]"; >>

E un’applicazione principale da eseguire

pacchetto org.primavera.MongodB.esempio; importare statico org.Springframework.dati.MongodB.nucleo.Domanda.Criteri.Dove; importare org.Apache.Comuni.registrazione.Tronco d'albero; importare org.Apache.Comuni.registrazione.Logfactory; importare org.Springframework.dati.MongodB.nucleo.Mongooperations; importare org.Springframework.dati.MongodB.nucleo.Mongotemplate; importare org.Springframework.dati.MongodB.nucleo.Domanda.Domanda; importare com.MongodB.Mongo; pubblico classe Mongoapp < privato statico finale Log log = logFactory.getlog (Mongoapp.classe); pubblico statico vuoto main (string [] args) lancia Eccezione < MongoOperations mongoOps = nuovo Mongotemplate (nuovo Mongo (), "Banca dati"); Mongoops.inserire(nuovo Persona("Joe", 34)); tronco d'albero.Informazioni (Mongoops.trova uno(nuovo Query (dove ("nome").È("Joe")), Persona.classe)); Mongoops.dropcollection ("persona"); >>

Questo produrrà il seguente output

10: 01: 32.062 Apping di debug.MongoperstiventityIndexcreator: 80 - Analisi delle classi di classe Org.primavera.esempio.Persona per informazioni sull'indice. 10: 01: 32.265 Debug Ramework.dati.MongodB.nucleo.Mongotemplate: 631 - Inserisci DBObject contenenti campi: [_class, età, nome] Nella raccolta: Persona 10: 01: 32.765 Debug Ramework.dati.MongodB.nucleo.Mongotemplate: 1243 - FindOne usando query: < "name" : "Joe">in db.Collezione: database.Persona 10: 01: 32.953 Info Org.primavera.MongodB.esempio.Mongoapp: 25 - Person [ID = 4DDBBA3C0BE56B7E1B210166, nome = Joe, età = 34] 10: 01: 32.984 Debug Ramework.dati.MongodB.nucleo.Mongotemplate: 375 - raccolta abbandonata [database.persona]

Anche in questo semplice esempio, ci sono poche cose da notare

  • È possibile istanziare la classe centrale dell’aiutante di Mongo primaverile, Mongotemplate, utilizzando lo standard Com.MongodB.Oggetto mongo e il nome del database da utilizzare.
  • Il mapper funziona contro gli oggetti Pojo standard senza la necessità di metadati aggiuntivi (anche se è possibile fornire facoltativamente tali informazioni. Vedere qui.).
  • Le convenzioni vengono utilizzate per gestire il campo ID, convertendolo in un oggettoId se memorizzato nel database.
  • Le convenzioni di mappatura possono utilizzare l’accesso al campo. Si noti che la classe persona ha solo getteri.
  • Se gli argomenti del costruttore corrispondono ai nomi dei campi del documento memorizzato, verranno utilizzati per istanziare l’oggetto

5.2 Esempi repository

C’è un repository GitHub con diversi esempi che puoi scaricare e giocare per avere un’idea di come funziona la biblioteca.

5.3 Collegamento a MongoDB con la molla

Una delle prime attività quando si utilizzano MongoDB e Spring è creare un com.MongodB.Oggetto Mongo usando il contenitore IOC. Esistono due modi principali per farlo, utilizzando metadati di fagioli a base di Java o metadati di fagioli a base XML. Questi sono discussi nelle seguenti sezioni.

Per coloro che non hanno familiarità con come configurare il contenitore a molla usando metadati di fagio.

5.3.1 Registrazione di un’istanza Mongo utilizzando metadati basati su Java

Un esempio di utilizzo dei metadati di fagioli a base di Java per registrare un’istanza di un com.MongodB.Mongo è mostrato di seguito

Esempio 5.1. Registrazione di un com.MongodB.Oggetto Mongo usando metadati di fagioli a base di Java

@Configurazione pubblico classe Appconfig < / * * Usa l'API del driver mongo standard per creare un com.MongodB.Mongo istanza. */ pubblico @Fagiolo Mongo Mongo () lancia UnknownHostException < ritorno nuovo Mongo ("Localhost"); >>

Questo approccio ti consente di utilizzare il com standard.MongodB.API Mongo che potresti già essere abituato all’utilizzo, ma anche inquina il codice con l’InnownHostException controllata l’eccezione. L’uso dell’eccezione verificata non è desiderabile in quanto i metadati di fagioli a base di Java utilizzano i metodi come mezzo per impostare le dipendenze degli oggetti, rendendo ingombra il codice chiamante.

Un’alternativa è registrare un’istanza di com.MongodB.Mongo istanza con il contenitore usando la MongoFactorybean di primavera . Rispetto all’istanziazione di un com.MongodB.Mongo Istance Direttamente, l’approccio di FactoryBean non lancia un’eccezione controllata e ha l’ulteriore vantaggio di fornire anche al contenitore un’implementazione di ExceptionTranslator che traduce le eccezioni di MongoDB alle eccezioni nella gerarchia portatile DataAccessception per le classi di accesso ai dati annote con l’annotazione @Repository. Questa gerarchia e l’uso di @Repository sono descritti nelle funzionalità di supporto DAO di Spring.

Un esempio di metadati di fagioli a base di Java che supporta la traduzione delle eccezioni sulle classi annotate @Repository è mostrato di seguito:

Esempio 5.2. Registrazione di un com.MongodB.Oggetto Mongo che utilizza la MongoFactorybean di Spring e l’abilitazione della traduzione delle eccezioni di primavera

@Configurazione pubblico classe Appconfig < / * * Bean di fabbrica che crea il com.MongodB.Mongo istanza */ pubblico @Fagiolo MongoFactorybean Mongo () < MongoFactoryBean mongo = nuovo MongoFactoryBean (); Mongo.Sethost ("Localhost"); ritorno Mongo; >>

Per accedere al com.MongodB.Oggetto Mongo creato da MongoFactoryBean in altri @configuration o le tue classi, usa un campo “privato @autowired Mongo Mongo;”.

5.3.2 Registrazione di un’istanza Mongo utilizzando metadati basati su XML

Mentre puoi usare lo spazio dei nomi XML tradizionale di Spring per registrare un’istanza di Com.MongodB.Mongo con il contenitore, l’XML può essere abbastanza verbosio in quanto è generale. Gli spazi dei nomi XML sono un’alternativa migliore alla configurazione di oggetti comunemente usati come l’istanza Mongo. Lo spazio dei nomi Mongo si trasforma per creare una posizione, set di replica e opzioni di Mongo Instance Server.

Per utilizzare gli elementi dello spazio dei nomi mongo dovrai fare riferimento allo schema Mongo:

Esempio 5.3. Schema XML per configurare MongoDB

  xmlns="http: // www.Springframework.org/schema/fagioli " XMLNS: XSI="http: // www.W3.org/2001/xmlschema-istance " XMLNS: contesto="http: // www.Springframework.org/schema/contesto " XMLNS: Mongo="http: // www.Springframework.Org/Schema/Data/Mongo " XSI: schemalocalizzazione= "http: // www.Springframework.org/schema/contesto http: // www.Springframework.Org/Schema/Context/Spring-Context-3.0.XSD http: // www.Springframework.Org/Schema/Data/Mongo http: // www.Springframework.Org/Schema/Data/Mongo/Spring-Mongo-1.0.XSD http: // www.Springframework.org/schema/fagioli http: // www.Springframework.Org/Schema/Beans/Spring-Beans-3.0.XSD ">   

Di seguito è visualizzata una configurazione più avanzata con Mongooptions (Nota Non sono valori consigliati)

Esempio 5.4. Schema XML per configurare un com.MongodB.Oggetto Mongo con Mongooptions

  ospite="Localhost" porta="27017">  connessioni per host="8" Discussioni-tollette-al blocco per la connessione-multiplicatore="4" Connect-timeout="1000" Max-Wait-Time="1500>" recupero automatico="VERO" Socket-keep-alive="VERO" socket-timeout="1500" slave-ok="VERO" Scrivi-numero="1" Write-timeout="0" Write-Fsync="VERO"/>   

Di seguito è mostrata una configurazione che utilizza i set di replica.

Esempio 5.5. Schema XML per configurare com.MongodB.Oggetto mongo con set di replica

 id="ReplicAsetmongo" replica set="127.0.0.1: 27017, localhost: 27018 "/> 

5.3.3 L’interfaccia MongoDBFactory

Mentre com.MongodB.Mongo è il punto di ingresso all’API del driver MongoDB, che si collega a un’istanza di database MongoDB specifica richiede ulteriori informazioni come il nome del database e un nome utente e una password opzionali. Con tali informazioni puoi ottenere un com.MongodB.Oggetto DB e accedere a tutte le funzionalità di un’istanza specifica del database MongoDB. La primavera fornisce l’organizzazione.Springframework.dati.MongodB.nucleo.Interfaccia MongoDBFactory mostrata di seguito alla connettività bootstrap nel database.

pubblico interfaccia MongoDBFactory < DB getDb() lancia DataaccessException; Db getdb (string dbname) lancia DataaccessException; >

Le seguenti sezioni mostrano come è possibile utilizzare il Contiainer con i metadati basati su Java o XML per configurare un’istanza dell’interfaccia MongoDBFactory. A sua volta, è possibile utilizzare l’istanza MongoDBFactory per configurare MongoTemplate.

L’organo di classe.Springframework.dati.MongodB.nucleo.SimplemondBFactory fornisce implementa l’interfaccia MongoDBFactory ed è creata con un com standard.MongodB.Mongo istanza, il nome del database e un’organizzazione opzionale.Springframework.dati.autenticazione.UserCredentials Argomento del costruttore.

Invece di usare il contenitore IOC per creare un’istanza di Mongotemplate, puoi semplicemente usarli nel codice Java standard come mostrato di seguito.

pubblico classe Mongoapp < privato statico finale Log log = logFactory.getlog (Mongoapp.classe); pubblico statico vuoto main (string [] args) lancia Eccezione < MongoOperations mongoOps = nuovo Mongotemplate (New SimplemondBFactory (new Mongo (), "Database")); Mongoops.inserire(nuovo Persona("Joe", 34)); tronco d'albero.Informazioni (Mongoops.trova uno(nuovo Query (dove ("nome").È("Joe")), Persona.classe)); Mongoops.dropcollection ("persona"); >>

Il codice in grassetto evidenzia l’uso di SimplemondBFactory ed è l’unica differenza tra l’elenco mostrato nella sezione.

5.3.4 Registrazione di un’istanza MongoDBFactory utilizzando metadati basati su Java

Per registrare un’istanza MongoDBFactory con il contenitore, si scrive un codice molto simile a quello che è stato evidenziato nell’elenco del codice precedente. Un semplice esempio è mostrato di seguito

@Configurazione pubblico classe Mongoconfiguration < pubblico @Fagiolo MongoDBFactory MongoDBFactory () lancia Eccezione < ritorno nuovo SimplemondBFactory (nuovo Mongo (), "Banca dati"); >>

Per definire il nome utente e la password crea un’istanza di Org.Springframework.dati.autenticazione.UserCredentials e passarlo al costruttore come mostrato di seguito. Questo elenco mostra anche utilizzando MongoDBFactory Register un’istanza di Mongotemplate con il contenitore.

@Configurazione pubblico classe Mongoconfiguration < pubblico @Fagiolo MongoDBFactory MongoDBFactory () lancia Eccezione < UserCredentials userCredentials = nuovo UserCredentials ("Joe", "segreto"); ritorno nuovo SimplemondBFactory (nuovo Mongo (), "Banca dati", UserCredentials); > pubblico @Fagiolo Mongotemplate Mongotemplate () lancia Eccezione < ritorno nuovo MongoTemplate (MongoDBFactory ()); >>

5.3.5 Registrazione di un’istanza MongoDBFactory utilizzando metadati basati su XML

Lo spazio dei nomi Mongo fornisce un modo convientato per creare un semplicissimo rispetto all’utilizzo dello spazio dei nomi. L’uso semplice è mostrato di seguito

 dbname="Banca dati">

Nell’esempio sopra un com.MongodB.L’istanza Mongo viene creata utilizzando l’host predefinito e il numero di porta. Il sempliciano SimpleMongoDBFactory con il contenitore è identificato dall’ID “MongoDBFactory” a meno che non venga specificato un valore per l’attributo ID.

È inoltre possibile fornire l’host e la porta per il Com sottostante.MongodB.Mongo istanza come mostrato di seguito, oltre al nome utente e alla password per il database.

 id="AnothermondBFactory" ospite="Localhost" porta="27017" dbname="Banca dati" nome utente="Joe" parola d'ordine="segreto"/>

Se è necessario configurare opzioni aggiuntive sul com.MongodB.Mongo istanza che viene utilizzata per creare un semplicissimo puoi fare riferimento a un fagiolo esistente usando l’attributo Mongo-ref come mostrato di seguito. Per mostrare un altro modello di utilizzo comune, questo elenco mostra l’uso di un segnaposto di proprietà per parametrizzare la configurazione e la creazione di mongotemplate .

 posizione="ClassPath:/com/myapp/mongodb/config/mongo.proprietà"/>  ospite="$" porta="$">  connessioni per host="$" Discussioni-tollette-al blocco per la connessione-multiplicatore="$" Connect-timeout="$" Max-Wait-Time="$" recupero automatico="$" Socket-keep-alive="$" socket-timeout="$" slave-ok="$" Scrivi-numero="1" Write-timeout="0" Write-Fsync="VERO"/>   dbname="Banca dati" Mongo-ref="Mongo"/>  id="Un altro Mongotemplate" classe="org.Springframework.dati.MongodB.nucleo.Mongotemplate ">  nome="MongoDBFactory" rif="MongoDBFactory"/> 

5.4 Introduzione a Mongotemplate

Il Mongotemplate di classe, situato nell’org di pacchetto.Springframework.dati.documento.MongoDB, è la classe centrale del supporto MongoDB della primavera Providng una ricca funzionalità impostata per interagire con il database. Il modello offre operazioni di convenienza per creare, aggiornare, eliminare e fare query per i documenti MongoDB e fornisce una mappatura tra oggetti di dominio e documenti MongoDB.

Una volta configurato, MongoTemplate è thread-safe e può essere riutilizzato in più istanze.

La mappatura tra documenti MongoDB e classi di dominio viene eseguita delegando a un’implementazione dell’interfaccia mongonverter . Spring fornisce due implementazioni, SimpleMappingConverter e MongomappingConverter, ma puoi anche scrivere il tuo convertitore. Fare riferimento alla sezione su Mongocoverter per informazioni più dettagliate.

La classe Mongotemplate implementa le mongooperazioni dell’interfaccia . Nel più possibile, i metodi sulle mongooperazioni prendono il nome dai metodi disponibili sull’oggetto di raccolta del driver MongoDB come rendere l’API familiare agli sviluppatori MongoDB esistenti che sono abituati all’API del driver. Ad esempio, troverai metodi come “Find”, “FindandModify”, “Findone”, “Insert”, “Remove”, “Save”, “Update” e “UpdateMulti”. L’obiettivo di progettazione era renderlo il più semplice possibile per la transizione tra l’uso del driver MongoDB di base e le mongooperazioni . Una grande differenza tra le due API è che le mongoperazioni possono essere superate gli oggetti del dominio anziché DBObject e ci sono API fluenti per query, criteri e operazioni di aggiornamento invece di popolare un dBobject per specificare i parametri per quelle operatiosn.

Il modo preferito per fare riferimento alle operazioni sull’istanza Mongotemplate è tramite la sua interfaccia Mongooperations .

L’implementazione del convertitore predefinita utilizzata da Mongotemplate è MongomapingConverter. Mentre il MongomapingConverter può utilizzare ulteriori metadati per specificare la mappatura degli oggetti ai documenti, è anche in grado di convertire oggetti che non contengono metadati additona. Queste convenzioni e l’uso delle annotazioni di mappatura sono spiegati nel capitolo della mappatura.

Nel rilascio M2 SimpleMapperConverter, era il valore predefinito e questa classe è ora deprecata in quanto la sua funzionalità è stata riassunta dal MongomappingConverter.

Un’altra caratteristica centrale di Mongotemplate è la traduzione di eccezioni delle eccezioni lanciate nel driver Java MongoDB nella gerarchia di eccezione di accesso dati portatili di Spring. Fare riferimento alla sezione sulla traduzione delle eccezioni per ulteriori informazioni.

Mentre ci sono molti metodi di convenienza su Mongotemplate per aiutarti a svolgere facilmente compiti comuni se è necessario accedere direttamente all’API del driver MongoDB per accedere alla funzionalità non esplicitamente esposta dal Mongotemplate È possibile utilizzare uno dei numerosi metodi di callback per accedere al driver sottostante. I callback di esecuzione ti darà un riferimento a un com.MongodB.Collezione o un com.MongodB.Oggetto DB. Per ulteriori informazioni, consultare la sezione Callback di esecuzione.

Ora diamo un’occhiata a esempi di come lavorare con il mongolomplate nel contesto del contenitore primaverile.

5.4. Istanziando Mongotemplate

È possibile utilizzare Java per creare e registrare un’istanza di Mongotemplate come mostrato di seguito.

Esempio 5.6. Registrazione di un com.MongodB.Oggetto Mongo e supporto per la traduzione delle eccezioni di primavera

@Configurazione pubblico classe Appconfig < pubblico @Fagiolo Mongo Mongo () lancia Eccezione < ritorno nuovo Mongo ("Localhost"); > pubblico @Fagiolo Mongotemplate Mongotemplate () lancia Eccezione < ritorno nuovo Mongotemplate (Mongo (), "mydatabase"); >>

Esistono diversi costruttori sovraccarichi di mongotemplate. Questi sono

  • Mongotemplate (Mongo Mongo, String Databasename) – prende il com.MongodB.Oggetto Mongo e il nome del database predefinito per operare.
  • Mongotemplate (Mongo Mongo, String Databasename, UserCredentials UserCredentials) – Aggiunge il nome utente e la password per l’autenticazione con il database.
  • Mongotemplate (MongoDBFactory MongoDBFactory) – prende un oggetto MongoDBFactory che incapsula il com.MongodB.Oggetto Mongo, nome del database, nome utente e password.
  • Mongotemplate (MongoDBFactory MongoDBFactory, Mongoconverter Mongoconverter) – Aggiunge un mongoConverter da utilizzare per la mappatura.

È inoltre possibile configurare un MongoTemplate usando lo schema XML di Spring.

"Localhost" porta ="27017"/> "Mongotemplate" classe="org.Springframework.dati.MongodB.nucleo.Mongotemplate "> "Mongo"/> "Databasename" valore ="Geospaziale"/> 

Altre proprietà opzionali che potresti voler impostare durante la creazione di un Mongotemplate sono le WriteResultChingPolicy, WriteConcer e Refereference predefinite .

Il modo preferito per fare riferimento alle operazioni sull’istanza Mongotemplate è tramite la sua interfaccia Mongooperations .

Politica di WriteResultChecking

Quando è in sviluppo è molto utile registrare o lanciare un’eccezione se il com.MongodB.WriteResult restituito da qualsiasi operazione MongoDB contiene un errore. È abbastanza comune dimenticare di farlo durante lo sviluppo e poi finire con un’applicazione che sembra funzionare con successo, ma in realtà il database non è stato modificato in base alle tue aspettative. Imposta la proprietà WriteResultChecking di MongoTemplate su un enum con i seguenti valori, registro, eccezione o nessuno per registrare l’errore, il lancio e l’eccezione o non fare nulla. L’impostazione predefinita è utilizzare un valore di WriteResultChecking di nessuno.

WriteConcern

Puoi impostare il com.MongodB.Proprietà WriteConcern che il MongoTemplate utilizzerà per le operazioni di scrittura se non è stato ancora specificato tramite il driver a un livello superiore come Com.MongodB.Mongo . Se la proprietà WriteConcern di MongoTemplate non viene impostata, sarà impostata su quella set nel DB o l’impostazione della raccolta del driver MongoDB.

WriteCondernResolver

Per casi più avanzati in cui si desidera impostare diversi valori WriteConcer su base per operazione (per remozioni, aggiorna, inserisci e salva le operazioni), un’interfaccia strategica chiamata WriteConcerResolver può essere configurata su Mongotemplate . Poiché Mongotemplate viene utilizzato per persistere a Pojos, WriteConcerResolver ti consente di creare una politica in grado di mappare una specifica classe Pojo a un valore WriteConcern. L’interfaccia WriteConcernResolver è mostrata di seguito.

pubblico interfaccia WriteCondernResolver

L’argomento passato, Mongoaction, è ciò che usi per determinare il valore WriteConcer da utilizzare o per utilizzare il valore del modello stesso come impostazione predefinita. Mongoaction contiene il nome della raccolta in cui è stato scritto, il Java.Lang.Classe del Pojo, il dBobject convertito, nonché l’operazione come enumerazione (mongoactionoperation: rimuovi, aggiorna, inserisci, insert_list, salva) e alcune altre informazioni contestuali. Per esempio,

Classe privata MyAppRiteConcerSolver implementa WriteConcerResolver < public WriteConcern resolve(MongoAction action) < if (action.getEntityClass().getSimpleName().contains("Audit")) < return WriteConcern.NONE; >altro se (azione.getEntityClass ().getSimplename ().contiene ("metadati")) < return WriteConcern.JOURNAL_SAFE; >Azione di ritorno.getDefaultWriteConcern (); >>

5.5 Salvare, aggiornare e rimuovere i documenti

MongoTemplate fornisce un modo semplice per salvare, aggiornare ed eliminare i tuoi oggetti di dominio e mappare quegli oggetti su documenti memorizzati in MongoDB.

Data una classe semplice come la persona

pubblico classe Persona < privato String ID; privato Nome stringa; privato int età; pubblico Persona (nome stringa, int età) < Questo.nome = nome; Questo.età = età; > pubblico String getID () < ritorno id; > pubblico Stringa getName () < ritorno nome; > pubblico int getAge () < ritorno età; > @Oltrepassare pubblico String toString () < ritorno "Person [id hl-string"> ", nome hl-string"> ", age hl-string"> "]"; >>

È possibile salvare, aggiornare ed eliminare l’oggetto come mostrato di seguito.

Mongooperations è l’interfaccia che Mongotemplate implementa.

pacchetto org.primavera.esempio; importare statico org.Springframework.dati.MongodB.nucleo.Domanda.Criteri.Dove; importare statico org.Springframework.dati.MongodB.nucleo.Domanda.Aggiornamento.aggiornamento; importare statico org.Springframework.dati.MongodB.nucleo.Domanda.Domanda.domanda; importare Giava.util.Elenco; importare org.Apache.Comuni.registrazione.Tronco d'albero; importare org.Apache.Comuni.registrazione.Logfactory; importare org.Springframework.dati.MongodB.nucleo.Mongooperations; importare org.Springframework.dati.MongodB.nucleo.Mongotemplate; importare org.Springframework.dati.MongodB.nucleo.SimplemondBFactory; importare com.MongodB.Mongo; pubblico classe Mongoapp < privato statico finale Log log = logFactory.getlog (Mongoapp.classe); pubblico statico vuoto main (string [] args) lancia Eccezione < MongoOperations mongoOps = nuovo Mongotemplate (nuovo SimplemondBFactory (nuovo Mongo (), "Banca dati")); Persona p = nuovo Persona("Joe", 34); // Insert viene utilizzato per archiviare inizialmente l'oggetto nel database. Mongoops.inserire (P); tronco d'albero.informazioni("Inserisci:" + P); // Trovare P = Mongoops.FindByID (p.getid (), persona.classe); tronco d'albero.informazioni("Trovato: " + P); // Aggiornamento Mongoops.UpdateFirst (query (dove ("nome").È("Joe")), aggiornamento("età", 35), Persona.classe); P = Mongoops.findone (query (dove ("nome").È("Joe")), Persona.classe); tronco d'albero.informazioni("Aggiornato:" + P); // Eliminare Mongoops.rimuovere (P); // Controlla che la cancellazione ha funzionato Elenca le persone = Mongoops.Trovate (persona.classe); tronco d'albero.informazioni("Numero di persone =:" + persone.misurare()); Mongoops.DropCollection (persona.classe); >>

Ciò produrrebbe il seguente output di registro (inclusi i messaggi di debug dallo stesso Mongotemplate)

Apping di debug.MongoperstiventityIndexcreator: 80 - Analisi delle classi di classe Org.primavera.esempio.Persona per informazioni sull'indice. Lavoro di debug.dati.MongodB.nucleo.Mongotemplate: 632 - Inserisci DBObject contenenti campi: [_class, età, nome] Nella raccolta: persona informatica Org.primavera.esempio.Mongoapp: 30 - Insert: Person [ID = 4DDC6E784CE5B1eba3Ceaf5c, nome = Joe, età = 34] DEBUG Work.dati.MongodB.nucleo.Mongotemplate: 1246 - FindOne usando query: < "_id" : < "$oid" : "4ddc6e784ce5b1eba3ceaf5c">> in db.Collezione: database.persona informatica org.primavera.esempio.Mongoapp: 34 - trovato: persona [id = 4ddc6e784ce5b1eba3ceaf5c, nome = joe, età = 34] lavoro di debug.dati.MongodB.nucleo.Mongotemplate: 778 - Chiamata Aggiornamento usando query: < "name" : "Joe">e aggiornamento: < "$set" : < "age" : 35>> In raccolta: lavoro di debug per persona.dati.MongodB.nucleo.Mongotemplate: 1246 - FindOne usando query: < "name" : "Joe">in db.Collezione: database.persona informatica org.primavera.esempio.Mongoapp: 39 - Aggiornato: persona [ID = 4DDC6E784CE5B1eba3Ceaf5c, nome = Joe, età = 35] DEBUG Work.dati.MongodB.nucleo.Mongotemplate: 823 - Rimuovi usando la query: < "id" : "4ddc6e784ce5b1eba3ceaf5c">Nella raccolta: Org Info Person.primavera.esempio.Mongoapp: 46 - Numero di persone =: 0 Debug Work.dati.MongodB.nucleo.MongoTemplate: 376 - raccolta dropy [database.persona]

C’è stata una conversione implicita usando il mongonverter tra una stringa e objectId come archiviato nel database e riconoscere una convenzione del nome “ID” della proprietà “ID”.

Questo esempio ha lo scopo di mostrare l’uso di salvare, aggiornare e rimuovere le operazioni su Mongotemplate e non mostrare funzionalità di mappatura complessa

La query stynax utilizzata nell’esempio è spiegata più dettagliatamente nei documenti di interrogazione della sezione.

5.5.1 Come viene gestito il campo “_id” nel livello di mappatura

MongoDB richiede di avere un campo “_id” per tutti i documenti. Se non ne fornisci uno, il driver assegnerà a un oggetto con un valore generato. Quando si utilizza MongomapingConverter ci sono alcune regole che regolano il modo in cui le proprietà della classe Java sono mappate in questo campo “_id”.

Il seguente delinea quale proprietà verrà mappata sul campo del documento “_id”:

  • Una proprietà o un campo annotato con @id (org.Springframework.dati.annotazione.Id) verrà mappato sul campo “_id”.
  • Una proprietà o un campo senza annotazione ma ID denominato verrà mappato nel campo “_id”.

Il seguente delinea quale tipo di conversione, se presente, verrà eseguita sulla proprietà mappata nel campo del documento _id quando si utilizza il mappingiNonGonverter, il predefinito per MongoTemplate .

  • Una proprietà ID o un campo dichiarato come una stringa nella classe Java verrà convertita e memorizzata come oggetto, se possibile, utilizzando un convertitore a molla . Le regole di conversione valide sono delegate al driver Java MongoDB. Se non può essere convertito in un objectID, il valore verrà archiviato come stringa nel database.
  • Una proprietà ID o un campo dichiarato come biginteger nella classe Java verrà convertito e memorizzato come un oggetto con un convertitore a molla .

Se non è presente alcun campo o proprietà specificato nella classe Java, un file “_id” implicito verrà generato dal driver ma non mappato a una proprietà o sul campo della classe Java.

Quando si interroga e si aggiorna Mongotemplate utilizzerà il convertitore per gestire le conversioni della query e aggiornare gli oggetti che corrispondono alle regole di cui sopra per il salvataggio dei documenti, quindi i nomi e i tipi di campi utilizzati nelle domande saranno in grado di abbinare ciò che è nelle classi di dominio.

5.5.Mappatura a 2 tipi

Poiché le raccolte MongoDB possono contenere documenti che rappresentano istanze di una varietà di tipi. Un ottimo esempio qui è se memorizzi una gerarchia di classi o semplicemente hai una classe con un oggetto di proprietà di tipo . In quest’ultimo caso i valori contenuti all’interno di quella proprietà devono essere letti correttamente quando si recano l’oggetto. Quindi abbiamo bisogno di un meccanismo per archiviare le informazioni del tipo insieme al documento effettivo.

Per raggiungere questo obiettivo il mappingonververter utilizza un’astrazione MongoTypeMapper con Default MongoTypeMapper come la principale implementazione. Il suo comportamento predefinito sta archiviando il nome di classe completamente qualificato in _class all’interno del documento per il documento di alto livello, nonché per ogni valore se è un tipo complesso e un sottotipo del tipo di proprietà dichiarato.

Esempio 5.7. Mappatura del tipo

pubblico classe Campione < Contact value; >pubblico astratto classe Contatto < … >pubblico classe Persona si estende Contatto < … >Campione campione = nuovo Campione(); campione.valore = nuovo Persona(); Mongotemplate.Salva (campione); < "_classe" : "com.acme.Campione", "valore" : < "_classe" : "com.acme.Persona" >>

Come puoi vedere, archiviamo le informazioni del tipo per la Classe Root effettiva Persistet e per il tipo nidificato in quanto è complesso e un sottotipo di contatto . Quindi se stai usando Mongotemplate.findall (oggetto.classe, “campione”) siamo in grado di scoprire che il documento memorizzato deve essere un’istanza di esempio. Siamo anche in grado di scoprire che la proprietà del valore deve essere effettivamente una persona.

Personalizzazione della mappatura dei tipi

Nel caso in cui desideri evitare di scrivere l’intero nome della classe Java come informazione del tipo, ma piuttosto ti piace usare una chiave, puoi usare l’annotazione @Typealies alla classe di entità. Se è necessario personalizzare la mappatura ancora di più, dai un’occhiata all’interfaccia typeinformationmapper. Un’istanza di quell’interfaccia può essere configurata nel defaultmonmontypemapper che può essere configurato a sua volta mappongoconverter .

5.5.3 metodi per il salvataggio e l’inserimento di documenti

Esistono diversi metodi convenienti su Mongotemplate per il salvataggio e l’inserimento dei tuoi oggetti. Per avere un controllo a grana più fine sul processo di conversione è possibile registrare i convertitori a molla con il mappingiNonververter, ad esempio convertitore e convertitore .

La differenza tra operazioni di inserto e salvataggio è che un’operazione di salvataggio eseguirà un inserto se l’oggetto non è già presente.

Il semplice caso di utilizzo dell’operazione di salvataggio è salvare un pojo. In questo caso il nome di raccolta sarà determinato per nome (non completamente qualificato) della classe. Puoi anche chiamare l’operazione di salvataggio con un nome di raccolta specifico. La raccolta per archiviare l’oggetto può essere sovrascritto usando i metadati di mappatura.

Quando si inserisce o risparmiano, se la proprietà ID non è impostata, il presupposto è che il suo valore sarà automatico dal database. In quanto tale, per l’autogenerazione di un oggetto INGHIGID per succedere al tipo di proprietà/campo ID nella classe deve essere una stringa, objectId o biginteger .

Ecco un esempio di base sull’uso dell’operazione di salvataggio e nel recupero del suo contenuto.

Esempio 5.8. Inserimento e recupero di documenti utilizzando il Mongotemplate

importare statico org.Springframework.dati.MongodB.nucleo.Domanda.Criteri.Dove; importare statico org.Springframework.dati.MongodB.nucleo.Domanda.Criteri.domanda; ... persona p = nuovo Persona("Bob", 33); Mongotemplate.inserire (P); Persona qp = mongotemplate.findone (query (dove ("età").È(33)), Persona.classe);

Le operazioni di inserto/salvataggio disponibili sono elencate di seguito.

  • vuoto salva (Oggetto ObjectTosave) Salva l’oggetto nella raccolta predefinita.
  • vuoto salva (Oggetto ObjectTosave, String CollectionName) Salva l’oggetto nella raccolta specificata.

Di seguito è elencato un set simile di operazioni di inserto

  • vuoto inserire (Oggetto objectTosave) Inserire l’oggetto alla raccolta predefinita.
  • vuoto inserire (Oggetto ObjectTosave, String CollectionName) Inserire l’oggetto alla raccolta specificata.

In quale raccolta i miei documenti verranno salvati?

Esistono due modi per gestire il nome di raccolta utilizzato per operare sui documenti. Il nome di raccolta predefinito utilizzato è il nome di classe modificato per iniziare con una lettera minuscola. Quindi un com.test.La classe della persona sarebbe memorizzata nella collezione “persona”. Puoi personalizzarlo fornendo un nome di raccolta diverso utilizzando l’annotazione @Document. È inoltre possibile sovrascrivere il nome di raccolta fornendo il tuo nome di raccolta come ultimo parametro per le chiamate del metodo Mongotemplate selezionate.

Inserimento o salvataggio di singoli oggetti

Il driver MongoDB supporta l’inserimento di una raccolta di documenti in una sola operazione. I metodi nell’interfaccia Mongooperations che supportano questa funzionalità sono elencati di seguito

  • inserire Inserire un oggetto. Se esiste un documento esistente con lo stesso ID, viene generato un errore.
  • InsertAll Prende una raccolta di oggetti come primo parametro. Questo metodo ispeziona ogni oggetto e lo inserisce alla raccolta appropriata in base alle regole sopra specificate.
  • salva Salva l’oggetto ovewriting qualsiasi oggetto che potrebbe esistere con lo stesso ID.

Inserimento di più oggetti in un batch

Il driver MongoDB supporta l’inserimento di una raccolta di documenti in una sola operazione. I metodi nell’interfaccia Mongooperations che supportano questa funzionalità sono elencati di seguito

  • inserire metodi che prendono una raccolta come primo argomento. Questo inserisce un elenco di oggetti in un singolo batch scrivere nel database.

5.5.4 Aggiornamento dei documenti in una raccolta

Per gli aggiornamenti possiamo scegliere di aggiornare il primo documento trovato utilizzando il metodo di Mongooperation UpdateFirst o possiamo aggiornare tutti i documenti che sono stati trovati per corrispondere alla query utilizzando il metodo UpdateMulti . Ecco un esempio di un aggiornamento di tutti gli account di risparmio in cui stiamo aggiungendo $ 50.00 bonus al saldo utilizzando l’operatore $ inc.

Esempio 5.9. Aggiornamento dei documenti utilizzando il Mongotemplate

importare statico org.Springframework.dati.MongodB.nucleo.Domanda.Criteri.Dove; importare statico org.Springframework.dati.MongodB.nucleo.Domanda.Domanda; importare statico org.Springframework.dati.MongodB.nucleo.Domanda.Aggiornamento; . WriteResult WR = Mongotemplate.updatemulti (nuovo Query (dove ("Account.Tipo di account").è (account.Tipo.Risparmio)), nuovo Aggiornamento().Inc ("Account.$.bilancia", 50.00), Account.classe);

Oltre alla query discussa sopra, forniamo la definizione di aggiornamento utilizzando un oggetto di aggiornamento. La classe di aggiornamento ha metodi che corrispondono ai modificatori di aggiornamento disponibili per MongoDB.

Come puoi vedere, la maggior parte dei metodi restituisce l’oggetto aggiornamento per fornire uno stile fluente per l’API.

Metodi per l’esecuzione di aggiornamenti per i documenti

  • UpdateFirst Aggiorna il primo documento che corrisponde ai criteri del documento di query con il documento aggiornato fornito.
  • updatemulti Aggiorna tutti gli oggetti che corrispondono ai criteri del documento di query con il documento aggiornato fornito.

Iniziare con MongoDB e Java – Crud Operations Tutorial

La registrazione del driver Java MongoDB è ora abilitata tramite la popolare API SLF4J, quindi ho aggiunto Logback nel POM.XML e un logback del file di configurazione.XML .

introduzione

Badge java

In questo primo post sul blog della serie Java Quick Start, ti mostrerò come impostare il tuo progetto Java con Maven ed eseguire un comando MongoDB in Java. Quindi esploreremo le operazioni più comuni – come creare, leggere, aggiornare ed eliminare – utilizzando il driver Java MongoDB . Ti mostrerò anche alcune delle opzioni e delle funzionalità più potenti disponibili come parte del driver MongoDB Java per ciascuna di queste operazioni, dandoti una base davvero eccezionale di conoscenza su cui basarci.

Nei futuri post sul blog, andremo avanti e lavoreremo attraverso:

Transazioni con acido multi-documento.

Il driver di flussi reattivi java mongodb.

Perché Mongodb e Java?

Java è la lingua più popolare nel settore IT alla data di questo post sul blog e gli sviluppatori hanno votato MongoDB come il loro database più ricercato per quattro anni consecutivi . In questa serie di post sul blog, dimostrerò quanto siano potenti questi due grandi pezzi di tecnologia quando si combinano e come puoi accedere a quella potenza.

Prerequisiti

Per seguire, puoi usare qualsiasi ambiente che ti piace e l’ambiente di sviluppo integrato di tua scelta. Userò Maven 3.6.2 e Java OpenJDK 13, ma tutto il codice sarà compatibile con le versioni Java da 8 a 13, quindi sentiti libero di usare il JDK di tua scelta e aggiornare la versione Java di conseguenza nel POM.File XML che stiamo per configurare.

Per il cluster MongoDB, utilizzeremo un cluster MongoDB a livello libero M0 di MongoDB Atlas . Se non ne hai già uno, dai un’occhiata al mio post sul blog del cluster M0.

Ottieni oggi il tuo cluster M0 gratuito sull’atlante MongoDB. È gratuito per sempre e sarai in grado di usarlo per lavorare con gli esempi in questa serie di blog.

Saltiamo e diamo un’occhiata a quanto bene Java e Mongodb lavorano insieme.

Essere impostato

Per cominciare, dovremo impostare un nuovo progetto Maven. Hai due opzioni a questo punto. Puoi clonare il repository git di questa serie o puoi creare e configurare il progetto Maven.

Utilizzando il repository Git

Se scegli di utilizzare Git, otterrai immediatamente tutto il codice. Ti consiglio ancora di leggere la configurazione manuale.

Puoi clonare il repository se lo desideri con il seguente comando.

Oppure puoi scaricare il repository come file zip .

Impostare manualmente

Puoi utilizzare il tuo IDE preferito per creare un nuovo progetto Maven per te o puoi creare manualmente il progetto Maven. Ad ogni modo, dovresti ottenere la seguente architettura della cartella:

Il pom.Il file XML dovrebbe contenere il seguente codice:

Per verificare che tutto funzioni correttamente, dovresti essere in grado di creare ed eseguire un semplice “Ciao MongoDB!” programma. In SRC/Main/Java/Com/MongoDB/QuickStart, crea HellOnongoDB.file java:

Quindi compila ed eseguilo con l’IDE o usa la riga di comando nella directory principale (dove si trova la cartella SRC):

Il risultato dovrebbe apparire così:

Nota: se vedi alcuni avvertimenti su un accesso riflessivo illegale da Guice.Java, è sicuro ignorarli. Guice viene utilizzato da Maven e ha bisogno di un aggiornamento. Puoi saperne di più in questo problema . Questi avvertimenti scompariranno in una futura uscita di Guice e Maven.

Connessione con Java

Ora che il nostro progetto Maven funziona e abbiamo risolto le nostre dipendenze, possiamo iniziare a utilizzare MongoDB Atlas con Java.

Se hai importato il set di dati di esempio come suggerito nel post sul blog Atlas Quick Start, quindi con il codice Java che stiamo per creare, sarai in grado di vedere un elenco dei database nel set di dati di esempio.

Il primo passo è quello di istanziare un mongolo passando una stringa di connessione atlante mongodb nei mongo.Crea () metodo statico. Ciò stabilirà una connessione ad Atlas MongoDB utilizzando la stringa di connessione. Quindi possiamo recuperare l’elenco dei database su questo cluster e stamparli per testare la connessione con MongoDB.

In SRC/Main/Java/Com/MongoDB, crea la connessione.file java:

Come puoi vedere, la stringa di connessione MongoDB viene recuperata da Proprietà di sistema , Quindi dobbiamo configurarlo. Dopo aver recuperato la stringa di connessione Atlas MongoDB, è possibile aggiungere il MongoDB.Proprietà del sistema Uri nel tuo IDE. Ecco la mia configurazione con Intellij, ad esempio.

O se preferisci utilizzare Maven nella riga di comando, ecco la riga di comando equivalente che puoi eseguire nella directory principale:

Nota: non dimenticare le doppie citazioni intorno all’URI MongoDB per evitare le sorprese dal tuo guscio.

L’output standard dovrebbe apparire così:

Inserire operazioni

Essere impostato

Nella sezione di connessione con Java, abbiamo creato le classi HellomongoDB e la connessione . Ora lavoreremo sulla classe Crea.

Se non hai impostato il tuo cluster gratuito su MongoDB Atlas, ora è il momento del momento per farlo. Ottieni le indicazioni per creare il tuo cluster .

Controllo del modello di raccolta e dati

Nel set di dati di esempio, è possibile trovare il database Sample_Training, che contiene un grado di raccolta . Ogni documento in questa raccolta rappresenta i voti di uno studente per una particolare classe.

Ecco la rappresentazione JSON di un documento nella shell di Mongo .

Ed ecco la rappresentazione JSON estesa dello stesso studente. Puoi recuperarlo nella bussola mongodb, il nostro strumento GUI gratuito, se vuoi.

JSON esteso è la versione leggibile umana di un documento BSON senza perdita di informazioni sul tipo. Puoi leggere di più sul driver Java e Bson nella documentazione del driver Java MongoDB .

Come puoi vedere, MongoDB memorizza i documenti BSON e per ogni coppia di valore chiave, il BSON contiene la chiave e il valore insieme al suo tipo. Questo è il modo in cui MongoDB sa che Class_id è in realtà un doppio e non un numero intero, che non è esplicito nella rappresentazione di Mongo Shell di questo documento.

Abbiamo 10.000 studenti (Student_ID da 0 a 9999) già in questa raccolta e ognuno di essi ha preso 10 classi diverse, il che aggiunge fino a 100.000 documenti in questa raccolta. Diciamo che un nuovo studente (Student_ID 10.000) è appena arrivato in questa università e ha ricevuto un sacco di voti (casuali) nella sua prima classe. Inseriremo questo nuovo documento studentesco usando Java e il driver MongoDB Java.

In questa università, Class_ID varia da 0 a 500, quindi posso usare qualsiasi valore casuale tra 0 e 500.

MongoDB Java Integrazione: 12 semplici passaggi

Inizia con MongoDB Crud Operations in Python: 3 semplici passaggi Aggregazione di sottostringa MongoDB (substr): semplificato 101 Connettore MongoDB JavaScript (Nodejs) semplificato 101

Sommario

Questa pagina fornisce una panoramica completa di come puoi iniziare con MongoDB e Java. In questo post, tu&rsquo;Imparerò come collegare la tua applicazione Java a un’istanza MongoDB. Quindi eseguirai alcune operazioni MongoDB comuni utilizzando il driver Java MongoDB. Leggi per impostare il tuo Mongodb Java Integrazione oggi!

Sommario

Cos’è MongoDB?

MongoDB è un database di documenti open source che ha una vasta gamma di applicazioni. Può essere utilizzato come database analitico, database transazionale, indice di ricerca o data warehouse, tra gli altri casi d’uso. MongoDB ha uno schema flessibile che fornisce supporto per l’indicizzazione completa, la replica, l’archiviazione simile a JSON e un linguaggio di query non strutturato.

I concetti chiave MongoDB sono:

  • Id: Un ID è un nome di campo che viene utilizzato per rappresentare un oggetto univoco in MongoDB. Può essere creato esplicitamente dall’utente o implicitamente dal server MongoDB.
  • Collezione: È un secchio che memorizza un gruppo di documenti MongoDB. Rientra in un database nella gerarchia.
  • Banca dati: Questo è il livello più alto di organizzazione dei dati in un’istanza MongoDB. Il database memorizza le raccolte e un’istanza MongoDB può contenere molti database.
  • Documento: I record memorizzati in una raccolta MongoDB sono chiamati documenti. Contengono chiavi e valori. I valori possono essere stringhe, numeri interi, booleani, date e altri documenti incorporati.
  • Campo: questo si riferisce alla coppia chiave/valore in un documento.

Risolvi i problemi di replica dei dati con pipeline affidabili, senza codice, automatizzate con 150 connettori.

Caratteristiche chiave di MongoDB

MongoDB ha diverse capacità straordinarie che lo rendono ampiamente utilizzabile e popolare. Diamo un’occhiata alle migliori caratteristiche tecniche di MongoDB:

Supporta le query ADHOC

Uno dei maggiori vantaggi che fanno risaltare MongoDB è la sua performance nel gestire le query ad hoc sui dati che vengono generalmente aggiornati in tempo reale. MongoDB può eseguire ricerche sul campo, ricerche di portata e query di espressione regolari.

Indicizzazione

L’indicizzazione è una caratteristica importante di un database per migliorare la velocità di ricerca e le prestazioni delle query di ricerca. Senza indicizzazione, un database sarebbe costretto a scansionare i documenti uno per uno per selezionare quelli che corrispondono alla query che sarebbe inefficiente. Tuttavia, se ogni query ha un indice appropriato, le richieste dell’utente possono essere eseguite rapidamente dal server. Con l’indicizzazione MongoDB è possibile con qualsiasi campo o chiave, in un documento che sostiene modelli di accesso complessi sui set di dati.

Database senza schema

I database relazionali classici utilizzano uno schema per definire ogni elemento funzionale, tra cui tabelle, visualizzazioni di righe, indici e relazioni. In MongoDB, una raccolta mantiene diversi documenti. Non ha schema, quindi ci possono essere numerosi documenti in una raccolta, con chiavi distinte, e queste chiavi potrebbero essere uniche. Un database di schema, come MongoDB, è più flessibile in quanto non porta questi vincoli iniziali, mappando a un database più naturale.

Per saperne di più su MongoDB, visita qui.

Cos’è Java?

Java è un linguaggio di programmazione popolare che&rsquo;S per lo più utilizzato per lo sviluppo del lato server e per lo sviluppo di app mobili. Nel suo design, Java è un linguaggio orientato agli oggetti che significa semplicemente che tutti i dati e i metodi sono rappresentati come classi e oggetti.

Java può essere compilato o interpretato, il che significa che la traduzione del codice Java in bytecode o in formato binario può essere eseguita usando un compilatore o un interprete. Da quel momento&rsquo;è un linguaggio compilato, esso&rsquo;è molto veloce in fase di esecuzione e anche molto facile da debug.

Alcuni casi d’uso di Top Java includono lo sviluppo:

  • Applicazioni Android
  • Applicazioni Desktop GUI
  • Applicazioni Web
  • Applicazioni scientifiche
  • Applicazioni sul lato server del settore finanziario
  • Sistemi integrati

Caratteristiche chiave di Java

Le seguenti caratteristiche danno a Java un vantaggio rispetto ad altri linguaggi di programmazione:

  • Orientato agli oggetti: Il linguaggio di programmazione Java tratta tutto come un oggetto. Può facilmente mappare gli scenari del mondo reale nel codice trattando le singole entità come oggetti.
  • Piattaforma indipendente: A differenza dei linguaggi di programmazione-come C e C ++, Java non viene compilato in una macchina specifica per la piattaforma. Produce un codice byte indipendente dalla piattaforma distribuita su Internet ed è interpretato dalla Java Virtual Machine (JVM) installata su qualsiasi sistema.
  • Sicurezza: Con la funzione di sicurezza del linguaggio di programmazione Java, consente di sviluppare sistemi a prova di manomissione e privi di virus. Inoltre, utilizza tecniche di autenticazione basate sulla crittografia a chiave pubblica per mantenere il codice e i dati sicuri.
  • Portatile: Java è un linguaggio di programmazione indipendente dall’architettura. Quindi è facile portare un codice scritto in linguaggio di programmazione Java a diversi processori.
  • Robusto: Java è un linguaggio di programmazione che si impegna ad eliminare le istanze soggette a errori utilizzando il controllo degli errori di compilazione e il controllo di runtime.

Per saperne di più sul linguaggio di programmazione Java, visita qui.

Semplifica l’analisi dei dati con la pipeline di dati senza codice di Hevo

Dati HEVO, una pipeline di dati senza codice automatizzata aiuta a caricare i dati da qualsiasi origine dati come database, applicazioni SAAS, archiviazione cloud, SDK, s e servizi di streaming e semplifica il processo ETL. Supporta oltre 100 fonti di dati come MongodB e carica i dati sul data warehouse desiderato, arricchisce i dati e li trasforma in un modulo pronto per l’analisi senza scrivere una singola riga di codice.

La sua pipeline completamente automatizzata offre dati da consegnare in tempo reale senza alcuna perdita da origine a destinazione. La sua architettura tollerante all’errore e scalabile garantisce che i dati siano gestiti in modo sicuro e coerente con zero perdita di dati e supporta diverse forme di dati. Le soluzioni fornite sono coerenti e funzionano anche con diversi strumenti di business intelligence (BI).

Scopri perché Hevo è il besT:

  • Sicuro: Hevo ha un’architettura tollerante all’errore che garantisce che i dati siano gestiti in modo sicuro e coerente con zero perdita di dati.
  • Gestione dello schema: Hevo toglie il noioso compito di gestione dello schema e rileva automaticamente lo schema dei dati in arrivo e lo mappa allo schema di destinazione.
  • Apprendimento minimo: Hevo, con l’interfaccia utente semplice e interattiva, è estremamente semplice per i nuovi clienti su cui lavorare ed eseguire operazioni.
  • Hevo è costruito per scalare: Man mano che il numero di fonti e il volume dei tuoi dati aumenta, Hevo si ridimensiona in orizzontale, gestendo milioni di record al minuto con pochissima latenza.
  • Carico di dati incrementale: Hevo consente il trasferimento di dati che sono stati modificati in tempo reale. Ciò garantisce un efficiente utilizzo della larghezza di banda su entrambe le estremità.
  • Supporto dal vivo: Il team HEVO è disponibile 24 ore su 24 per estendere il supporto eccezionale ai propri clienti tramite chat, e -mail e chiamate di supporto.
  • Monitoraggio in tempo reale: HEVO ti consente di monitorare il flusso di dati e verificare dove si trovano i dati in un determinato momento.

Quali sono i passaggi per impostare l’integrazione di MongoDB Java?

Spero, ormai, hai acquisito una comprensione di base di MongoDB e Java, nonché perché loro&rsquo;essere utilizzato nello sviluppo dell’applicazione. Adesso molla&rsquo;s immergere e dare un’occhiata ai passaggi utilizzando i quali è possibile impostare Mongodb Java integrazione:

  • Passaggio 1: installare il pacchetto OpenJDK
  • Passaggio 2: impostare la variabile ambientale Java_home
  • Passaggio 3: installa MongoDB
  • Passaggio 4: installa un IDE o un editor
  • Passaggio 5: imposta un nuovo progetto Java
  • Passaggio 6: installa la libreria client Java MongoDB
  • Passaggio 7: utilizzare la libreria client Java MongoDB
  • Passaggio 8: crea una collezione MongoDB
  • Passaggio 9: creare documenti
  • Passaggio 10: documenti di query
  • Passaggio 11: aggiorna i documenti
  • Passaggio 12: Elimina i documenti

Passaggio 1: installare il pacchetto OpenJDK

Seguire insieme alla configurazione di Java MongoDB, tu&rsquo;First, ho bisogno di preparare la macchina locale per lo sviluppo di Java. Per fare ciò, è necessario installare prima il pacchetto OpenJDK 8 (Open Java Development Kit).

1) Linux

Se tu&rsquo;RE su Debian o Ubuntu, apri la tua riga di comando ed esegui il comando seguente:

$ sudo apt-get Installa OpenJDK-8-JDK

Per CentOS, Red Hat, Oracle, Fedora e altre distribuzioni Linux simili utilizzano il seguente comando:

$ su -c "yum install java -1.8.0-openjdk-devel "

2) MacOS

Se tu&rsquo;re su macOS utilizzare il seguente comando:

% Brew Installa OpenJDK@8

Quindi crea un collegamento simbolico in modo che l’involucro Java possa trovarlo:

% sudo ln -sfn/usr/local/opt/openjdk@8/libexec/openjdk.JDK/Library/Java/Javavirtualmachines/OpenJDK-8.JDK 

3) Windows

  • Scarica il programma di installazione basato su MSI da questo link.
  • Estrai i file zip in una cartella.
  • Esegui OpenJDK 8 per Windows Installer.
  • Segui l’installazione delle istruzioni sullo schermo.

Passaggio 2: impostare la variabile ambientale Java_home

Una volta che il tuo JDK è in atto, è necessario installare l’ambiente Java per procedere con l’integrazione MongoDB Java.

1) Linux

  1. Apri il tuo terminale e tipo:

sudo nano /etc /profilo

  1. Quindi vai alla fine del file e digita:

esporta java_home =/usr/lib/jvm/java-8-openjdk-amd64/bin/java percorso di esportazione = $ java_home/bin: $ path

  1. Salva il file ed esci (Ctrl+O, Ctrl+X).

2) MacOS

  1. Apri il tuo terminale e tipo:

emacs .profilo

  1. Quindi vai alla fine del file e digita:

Java_home =/libreria/java/home esporta java_home;

  1. Salva ed esci (CTRL-X, CTRL-S; Ctrl-X, Ctrl-C).

3) Windows

Per impostare la variabile di ambiente sul computer Windows, aprire il prompt dei comandi con i privilegi di amministrazione ed eseguire il seguente comando:

setx -m java_home "c: prgra ~ 1javajdk1.8.0_xx "

Successivamente, riavvia il prompt dei comandi per ricaricare le variabili di ambiente. Esegui il comando seguente per verificare se il percorso è stato aggiunto:

echo %java_home %

Passaggio 3: installa MongoDB

Una volta che hai finito con la parte Java dell’integrazione di MongoDB Java, è tempo di installare MongoDB e i suoi strumenti.

1) Linux

  1. Apri un terminale e emette il seguente comando per importare la chiave pubblica MongoDB dal sistema di gestione dei pacchetti:

Wget -qo - https: // www.MongodB.org/statico/pgp/server-5.0.ASC | sudo Apt-Key Aggiungi -

  1. Quindi crea un file di elenco emettendo il seguente comando:

echo "deb [arch = amd64, arm64] https: // repo.MongodB.Org/Apt/Ubuntu Focal/MongoDB-ORG/5.0 Multiverse "| sudo tee/etc/apt/fonti.elenco.D/MongoDB-ORG-5.0.elenco

  1. Aggiorna il database del pacchetto.

Sudo Apt-get Aggiornamento

  1. Esegui il seguente comando per installare MongoDB:

Sudo Apt-get Installa -y MongoDB-ORG

  1. Inizia MongoDB:

sudo systemctl avvia mongod

  1. Verificare che MongoDB sia in esecuzione:

sudo systemctl status mongod

MongoDB dovrebbe essere in esecuzione sulla porta 27017.

Le istruzioni sopra sono state testate su Ubuntu 20.0. È possibile ottenere le istruzioni di installazione per altre distribuzioni Linux dal seguente collegamento.

2) MacOS

  1. Emettere il seguente comando per scaricare la formula Homebrew per MongoDB:

Brew Tap MongoDB/Brew

  1. Installa MongoDB utilizzando il seguente comando:

Brew Installa [email protected]

  1. Per i computer MacOS che eseguono i processori Intel, avvia MongoDB utilizzando il seguente comando:

MONGOD -CONFIG/USR/LOCAL/ETC/MONGOD.conf - -fork

  1. Per i computer MacOS che eseguono i processori M1, utilizzare il comando seguente:

MONGOD -CONFIG/OPT/Homebrew/ETC/MONGOD.conf - -fork

3) Windows

  1. Scarica il programma di installazione basato su MongoDB da questo link.
  1. Eseguire l’installatore facendo doppio clic sul .file msi.
  1. Segui l’installazione delle istruzioni sullo schermo.

Passaggio 4: installa un IDE o un editor

Per eseguire gli esempi forniti in questo blog, ti consigliamo di utilizzare un ambiente di sviluppo integrato (IDE). Questo perché rende molto più conveniente per te configurare Maven o Gradle quando si costruisce e si esegue il tuo progetto Java.

Sotto di te&rsquo;Trova un elenco di alcuni redattori popolari utilizzati per sviluppare app Java e si adattano al tuo Mongodb Java integrazione:

  • Atom di GitHub
  • Idea Intellij di Jetbrains
  • Codice Visual Studio di Microsoft
  • Eclipse di Eclipse Foundation

Questi IDE offrono funzionalità utili come l’evidenziazione della sintassi, il completamento del codice, le funzionalità di debug completamente integrate e molto altro.

Passaggio 5: imposta un nuovo progetto Java

Usando il tuo IDE preferito, crea un nuovo progetto Maven o Gradle. Se tu&rsquo;Re usando Maven, dovresti ottenere la seguente struttura della cartella:

java-quick-start/ â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â â tiva.xml └── src └── main └── java └── com └── mongodb └── quickstart 

Se stai usando Gradle, dovresti avere la seguente struttura della cartella:

â â â â Â.gradle └── src └── main ├── java └──

Passaggio 6: installa la libreria client mongodb per Java

La libreria client MongoDB per Java ti consente di connetterti e comunicare con l’istanza MongoDB da un’applicazione Java.

Se si utilizza Maven, aggiungi la libreria client Java MongoDB all’elenco delle dipendenze nel tuo pom.XML file.

  org.MongodB Mongodb-driver-sync 4.4.1   

Tuo pom.XML Il file dovrebbe ora apparire così:

  4.0.0 com.MongodB Java-Quick-Start 1.0-snapshot 8 8 UTF-8 4.4.1 3.10.0   org.MongodB Mongodb-driver-sync $    org.Apache.Esperto di.plugin Plugin Maven-Compiler $ $ $     

Se tu&rsquo;RE Utilizzo di gradle, aggiungi il seguente frammento di codice al tuo costruire.Gradle Elenco delle dipendenze per l’integrazione di MongoDB Java:

dipendenze

Tuo costruire.Gradle Il file dovrebbe assomigliare al seguente file:

plugin < id 'base' >Org di importazione.Gradle.distribuzione.DownloadGradle versione = '0.1 'dipendenze < compile 'org.mongodb:mongodb-driver-sync:4.4.1' >compiti.Register ('DownloadGradle', DownloadGradle) < description = 'Downloads the Gradle distribution with a given version.' gradleVersion = '4.6' >compiti.Register ("CreateCustomgradledSistribution", Zip) < description = 'Builds custom Gradle distribution and bundles initialization scripts.' dependsOn downloadGradle def projectVersion = project.version archiveFileName = downloadGradle.gradleVersion.map < gradleVersion ->"MyCompany-gradle-$-$-bin.Zip "> From ZipTree (DownloadGradle.DestinationFile) da (src/init.D') < into "$/init.d" > > 

Passaggio 7: utilizzando la libreria client Java MongoDB

Per utilizzare la libreria client Java MongoDB, crea un file che conterrà l’applicazione all’interno della directory dei pacchetti di base del progetto. Puoi nominarlo App.Giava.

Aggiungi le seguenti dichiarazioni di importazione per inizializzare la libreria:

importare static com.MongodB.cliente.modello.Filtri.Eq; Org di importazione.bson.Documento; Importa com.MongodB.cliente.Mongoccliente; Importa com.MongodB.cliente.Mongottoni; Importa com.MongodB.cliente.Mongocollection; Importa com.MongodB.cliente.Mongodatabase;

Passaggio 8: crea una collezione MongoDB

Con quello fuori mano, esso&rsquo;s ora tempo che la tua integrazione MongoDB Java interagisce con il database. Permettere&rsquo;S Primo inizio creando una collezione. È possibile creare una raccolta MongoDB specificando il database di destinazione utilizzando il getDatabase () metodo e quindi invocare il createCollection () metodo del com.MongodB.cliente.Mongodatabase interfaccia. Questo metodo accetta un valore di stringa letterale con il nome della raccolta. Se il database non esiste, MongoDB lo creerà implicitamente.

Il seguente frammento di codice crea una raccolta in un database MongoDB:

Importa Java.util.Array; Org di importazione.bson.Documento; Org di importazione.bson.tipi.Objectid; Importa com.MongodB.Mongoexception; Importa com.MongodB.cliente.Mongoccliente; Importa com.MongodB.cliente.Mongottoni; Importa com.MongodB.cliente.Mongocollection; Importa com.MongodB.cliente.Mongodatabase; Importa com.MongodB.cliente.risultato.Insertonesult; Creazione di classe pubblica < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; // Create a MongoDB Client MongoClient mongoClient = MongoClients.create(uri)); // Create a MongoDB database MongoDatabase database = mongoClient.getDatabase("usersDB"); // Create a MongoDB Collection MongoCollectioncollection = database.createCollection("users"); System.out.println("Collection Created Successfully!"); > >

Passaggio 9: creare documenti

Il seguente frammento utilizza il insertOne () Metodo per inserire un documento nell’utente&rsquo;Collezione S che hai creato nel passaggio precedente. Se il database o la raccolta non esistono, MongoDB creerà entrambi.

Importa Java.util.Array; Org di importazione.bson.Documento; Org di importazione.bson.tipi.Objectid; Importa com.MongodB.Mongoexception; Importa com.MongodB.cliente.Mongoccliente; Importa com.MongodB.cliente.Mongottoni; Importa com.MongodB.cliente.Mongocollection; Importa com.MongodB.cliente.Mongodatabase; Importa com.MongodB.cliente.risultato.Insertonesult; Insertone di classe pubblica < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); try < InsertOneResult result = collection.insertOne(new Document() .append("_id", new ObjectId()) .append("username", "vitali@30") .append("phonenumber", 2501345876) .append("email", "[email protected]) ); System.out.println("Success! Inserted document id: " + result.getInsertedId()); >catch (Mongoexception me) < System.err.println("Unable to insert due to an error: " + me); >>>> 

È anche possibile inserire più documenti in una raccolta per un punto invocando il insertMany () metodo. Per inserire più documenti, devi aggiungerli a un elenco e passare quell’elenco come un array. Il seguente frammento di codice illustra come è possibile utilizzare il insertMany () metodo per raggiungere questo obiettivo.

Importa Java.util.Array; Importa Java.util.Elenco; Org di importazione.bson.Documento; Importa com.MongodB.Mongoexception; Importa com.MongodB.cliente.Mongoccliente; Importa com.MongodB.cliente.Mongottoni; Importa com.MongodB.cliente.Mongocollection; Importa com.MongodB.cliente.Mongodatabase; Importa com.MongodB.cliente.risultato.Insertmanyresult; Insertmany di classe pubblica < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); List userList = Arrays.asList( new Document().append("username", "owen hart"), new Document().append("username", "jack grealish")); try < InsertManyResult result = collection.insertMany(userList); System.out.println("Inserted document ids: " + result.getInsertedIds()); >catch (Mongoexception me) < System.err.println("Unable to insert due to an error: " + me); >>>> 

Passaggio 10: documenti di query

Lavorando con la tua integrazione MongoDB Java, puoi recuperare i documenti in una raccolta invocando il Trovare() metodo. Questo metodo restituisce un oggetto iterabile che contiene tutti i documenti in una raccolta:

Importa com.MongodB.cliente.Trovy; Importa com.MongodB.cliente.Mongocollection; Importa com.MongodB.cliente.Mongodatabase; Importa Java.util.Iteratore; Org di importazione.bson.Documento; Importa com.MongodB.Mongoccliente; Trova di classe pubblica < public static void main( String[] args ) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); FindIterable iterDoc = collection.find(); Iterator it = iterDoc.iterator(); while (it.hasNext()) < System.out.println(doc.it.next()); >>>> 

Passaggio 11: aggiorna i documenti

Gli aggiornamenti in un database MongoDB possono essere eseguiti utilizzando il aggiornamento () metodo del Aggiornamenti classe. Nel seguente esempio, aggiornerai il valore del numero di telefono e aggiungerai un indirizzo al documento che corrisponde al nome utente &ldquo;Vitali@30&rdquo;.

Org di importazione.bson.Documento; Org di importazione.bson.conversioni.Bson; Importa com.MongodB.Mongoexception; Importa com.MongodB.cliente.Mongoccliente; Importa com.MongodB.cliente.Mongottoni; Importa com.MongodB.cliente.Mongocollection; Importa com.MongodB.cliente.Mongodatabase; Importa com.MongodB.cliente.modello.Aggiornamenti; Importa com.MongodB.cliente.modello.Aggiornamenti; Importa com.MongodB.cliente.risultato.UpdateSult; Aggiornamento della classe pubblica < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); Document query = new Document().append("username", "vitali@30"); Bson updates = Updates.combine( Updates.set("phonenumber", 010154257), Updates.addToSet("address", "666, 5th Avenue, NYC")); UpdateOptions options = new UpdateOptions().upsert(true); try < UpdateResult result = collection.updateOne(query, updates, options); System.out.println("Modified document count: " + result.getModifiedCount()); System.out.println("Upserted id: " + result.getUpsertedId()); // only contains a value when an upsert is performed >catch (Mongoexception me) < System.err.println("Unable to update due to an error: " + me); >>>> 

Passaggio 12: Elimina i documenti

Una volta impostata l’integrazione di MongoDB Java, è comunque possibile eseguire un’operazione di eliminazione su un documento in un MongoDBCollection utilizzando il deleteone () metodo. Il metodo accetta un filtro query che corrisponde al documento che si desidera eliminare.

Il seguente frammento di codice eliminerà un utente utilizzando il Eq () Filtra per identificare un utente specifico con il nome utente &ldquo;Vitali@30&rdquo; Dalla tua integrazione MongoDB Java:

importare static com.MongodB.cliente.modello.Filtri.Eq; Org di importazione.bson.Documento; Org di importazione.bson.conversioni.Bson; Importa com.MongodB.Mongoexception; Importa com.MongodB.cliente.Mongoccliente; Importa com.MongodB.cliente.Mongottoni; Importa com.MongodB.cliente.Mongocollection; Importa com.MongodB.cliente.Mongodatabase; Importa com.MongodB.cliente.risultato.Deletesult; Classe pubblica elimina < public static void main(String[] args) < String uri = "mongodb://localhost:27017"; try (MongoClient mongoClient = MongoClients.create(uri)) < MongoDatabase database = mongoClient.getDatabase("usersDB"); MongoCollectioncollection = database.getCollection("users"); Bson query = eq("username", "vitali@30"); try < DeleteResult result = collection.deleteOne(query); System.out.println("Deleted document count: " + result.getDeletedCount()); >catch (Mongoexception me) < System.err.println("Unable to delete due to an error: " + me); >>>> 

Quello&rsquo;sedersi! Ora puoi impostare il tuo Mongodb Java integrazione.

Conclusione

Questo articolo ti ha introdotto il linguaggio di programmazione MongoDB e Java insieme alle loro caratteristiche chiave. Se hai completato con successo questa guida, dovresti avere una buona idea di come impostare il Mongodb Java integrazione. Hai coperto i passaggi necessari per impostare gli ambienti di sviluppo MongoDB e Java sul tuo PC o server. Hai anche coperto come utilizzare il driver Java per connettersi all’istanza MongoDB. Infine, hai visto esempi di come scrivere alcune semplici operazioni di MongoDB Java Crud.

MongoDB è un ottimo strumento per la memorizzazione dei dati aziendali. Tuttavia, a volte, è necessario trasferire questi dati in un data warehouse per ulteriori analisi. Costruire una soluzione interna per questo processo potrebbe essere un compito costoso e che richiede tempo. I dati HEVO, d’altra parte, offrono una pipeline di dati senza codice in grado di automatizzare il processo di trasferimento dei dati, consentendo quindi di concentrarti su altri aspetti della tua attività come analisi, gestione dei clienti, ecc. Questa piattaforma consente di trasferire dati da oltre 100 fonti come MongodB Per i data warehouse basati su cloud come Snowflake, Google BigQuery, Amazon Redshift, ecc. Ti fornirà un’esperienza senza problemi e renderà la tua vita lavorativa molto più semplice.

Voglio prendere Hevo per un giro? Iscriviti per una prova gratuita di 14 giorni e sperimenta in prima persona la suite Hevo Suite ricca di funzionalità.

Condividi le tue opinioni su Mongodb Java Integrazione nella sezione commenti!

Transazioni Java MongoDB: creazione, gestione e flussi di lavoro semplificati | Una guida 101

La gestione dei database ed eseguire diverse operazioni sui dati può essere impegnativa. Sono stati introdotti sistemi di gestione del database per risolvere i problemi di gestione e di lavoro dei dati raccolti. Uno dei database più popolari è MongoDB. MongoDB è uno dei database più flessibili e eseguirlo con Java lo rende ancora più veloce e più facile.

Sommario

In questo articolo, imparerai a conoscere le transazioni Java MongoDB. E inoltre, discuteremo di come creare, gestire e lavorare con le transazioni MongoDB.

Sommario

  1. Prerequisiti
  2. Cos’è MongoDB?
  3. Come eseguire MongoDB con Java?
  4. Cos’è la transazione MongoDB?
  5. Creazione di transazioni Java Mongodb
  6. Gestione delle transazioni Java MongoDB
  7. Flusso di lavoro delle transazioni Java Mongodb
  8. Conclusione

Prerequisiti

Comprensione di base dei database.

Cos’è MongoDB?

MongoDB è un database NOSQL fondamentalmente diverso dai database SQL. MongoDB è un database non relazionale, open source, indipendente dalla piattaforma e basato sui documenti. I database SQL memorizzano dati correlati nelle tabelle, mentre MongoDB tratta dati non correlati.

MongoDB supporta transazioni acido (atomicità, coerenza, isolamento e durata) in documenti singoli o multipli. Queste proprietà acide delle transazioni assicurano che le operazioni di transazione complesse siano sicure e affidabili, garantendo la validità dei dati. MongoDB ha introdotto più documenti, raccolte e transazioni acido dei database in MongoDB 4.0 versione.

MongoDB funziona su sistemi operativi standard, Windows, Linux, MacOS e Cloud. L’edizione MongoDB che funziona sul sistema operativo è il server della comunità MongoDB e l’installazione di MongoDB sul cloud si chiama MongoDB Atlas.

Come eseguire MongoDB con Java?

Prepara Java installata nel sistema e l’IDE (IDE) Prefered Integrated Development Environment). Per impostare Java e MongoDB, prima, dovresti ottenere il driver java mongodb. Le risorse per l’installazione di MongoDB saranno raccolte da due IDE a Gradle o Maven. I conducenti Java MongoDB forniscono interazioni sia sincroni che asincroni.

Passaggi per ottenere il driver java mongodb

  1. Installa la versione corretta del driver MongoDB da questo sito Web. Quindi, vai ai prodotti dall’icona del menu. Trovare il &lsquo;Dati diretti&rsquo; opzione e fare clic su di essa.

Passaggi per ottenere il driver java mongodb

  1. Verrai reindirizzato a un’altra pagina Web in cui puoi trovare il &lsquo;Connettività dei dati&rsquo; Opzione nel pannello Panoramica, in base al quale vedrai JDBC. Cliccaci sopra.

Passaggi per ottenere il driver java mongodb

  1. Un’altra pagina si aprirà. Cerca MongoDB dall’elenco e fai clic su di esso per spostarsi ulteriormente.

Passaggi per ottenere il driver java mongodb

  1. Verrà visualizzata una nuova pagina, dove vedrai l’opzione di download. Fai clic su di esso, quindi avrai due opzioni; Windows e Linux. Secondo il sistema del sistema operativo, fai clic su di esso per scaricare.

Passaggi per ottenere il driver java mongodb

  1. Devi compilare un modulo per il download e fare clic su Download.
  2. Dopo il download, estrai il file scaricato.
  3. Apri il file estratto per avviare l’installazione. Clicca su &lsquo;Prossimo&rsquo; procedere.
  4. Accetta tutti i termini e le condizioni, quindi vai avanti facendo clic su Avanti.
  5. Nota: non modificare nulla nelle prossime due Windows. Fai clic su Avanti per procedere.

Passaggi per ottenere il driver java mongodb

  1. Infine, raggiungerai l’opzione di installare. Fare clic su di esso e l’installazione inizierà.
  2. Attendere il completamento del processo di installazione.

Passaggi per ottenere il driver java mongodb

  1. Al termine dell’installazione, fare clic su Fine per terminare l’installazione.
  2. Apri la tua unità C e segui il percorso seguente. Se trovi una cartella JDBC, l’installazione ha esito positivo.

Ridimensionare l’integrazione dei dati senza sforzo con Hevo&rsquo;s Pipeline di dati di tollerante per guasti

Poiché la capacità delle aziende di raccogliere i dati esplode, i team di dati hanno un ruolo cruciale nel rifornimento di decisioni basate sui dati. Eppure, lottano per consolidare i dati sparsi nel loro magazzino per costruire un’unica fonte di verità. Pipeline rotte, problemi di qualità dei dati, bug ed errori e mancanza di controllo e visibilità sul flusso di dati rendono l’integrazione dei dati un incubo.

Oltre 1000 team di dati si affidano a Hevo&rsquo;S Piattaforma della pipeline di dati per integrare i dati da oltre 150 oltre fonti in pochi minuti. Miliardi di eventi di dati da fonti vari come app, database, archiviazione di file e fonti di streaming SAAS possono essere replicati in tempo reale con HEVO&rsquo;S Architettura tollerante alla faglia. Che cosa&rsquo;s Altro-Hevo mette il controllo completo nelle mani di team di dati con dashboard intuitivi per il monitoraggio della pipeline, la gestione automatica dello schema e i programmi di ingestione/caricamento personalizzati.

Questo, combinato con prezzi trasparenti e supporto 24 × 7, ci rende il software di pipeline di dati più speciale sui siti di revisione.

Prendi la nostra prova gratuita di 14 giorni per sperimentare un modo migliore per gestire le condutture di dati.

Cos’è la transazione MongoDB?

La transazione in MongoDB è un gruppo logico di processi che esegue una o più operazioni su più documenti. La transazione fornisce un modo per raggruppare e isolare più istruzioni ed elaborarle come un’unica operazione.

Invece di eseguire un mucchio di comandi individualmente, è possibile utilizzare le transazioni per raggruppare ed eseguire i comandi in un contesto diverso.

Queste operazioni nelle transazioni sono le operazioni multiple di lettura e scrittura fatte da e verso il database MongoDB. Le transazioni mantengono l’integrità dell’insieme di operazioni e forniscono una forte coerenza dei dati all’utente finale.

Le transazioni in mongodb hanno proprietà acide. Queste proprietà assicurano che le operazioni complesse siano sicure e affidabili. MongoDB supporta il multi-documento e il multi-documento distribuito.

Creazione di transazioni Java Mongodb

Le transazioni possono essere eseguite solo su database che vengono eseguiti come parte di un cluster di grandi dimensioni. Questo cluster può essere un cluster di database frastagliato o un set di replica. Di solito, le transazioni MongoDB sono scritte ed eseguite da applicazioni esterne tramite metodi API. Qui noi&rsquo;LL Crea una transazione usando la shell Mongodb.

Nota: Dopo il metodo iniziale StartTransaction (), l’operazione interromperà automaticamente se la sessione di transazione viene eseguita per più di 60 secondi.

Di seguito sono riportati i passaggi per concettualizzare una sessione di transazione dall’inizio alla fine.

db.autori.Trovare() [ < _id: ObjectId("620397dd4b871fc65c193106"), first_name: 'James', last_name: 'Joyce', title: 'Ulysses' >, < _id: ObjectId("620398016ed0bb9e23785973"), first_name: 'William', last_name: 'Gibson', title: 'Neuromancer' >, < _id: ObjectId("6203981d6ed0bb9e23785974"), first_name: 'George', last_name: 'Orwell', title: 'Homage to Catalonia' >, < _id: ObjectId("620398516ed0bb9e23785975"), first_name: 'James', last_name: 'Baldwin', title: 'The Fire Next Time' >" 

Lo stesso con un’API, si crea una sessione di transazione utilizzando il codice:

var session = db.getmongo ().avvio ()

Il prossimo passo è iniziare la transazione chiamando il metodo startTransaction (). Usa il comando seguente:

sessione.startTransaction ( < "readConcern": < "level": "snapshot" >, "WriteConcern": < "w": "majority >>) 

Esistono due opzioni per StartTransaction (): leggere preoccupazione e scrivere preoccupazione.

Il set di preoccupazioni di lettura viene ignorato all’interno della transazione a livello di raccolta e database. Pertanto, è necessario impostare la preoccupazione di lettura a livello di transazione su StartTransaction (). Tuttavia, la preoccupazione di lettura predefinita imposta la preoccupazione di lettura a livello di sessione per una transazione.

Se non vengono impostate sia il livello di lettura a livello di transazione che a livello di sessione, le preoccupazioni di lettura del livello del client sono impostate automaticamente. La preoccupazione di lettura a livello di cliente è &lsquo;Locale&rsquo; per letture contro il primario.

La preoccupazione per scrivere viene utilizzata per commettere le operazioni di scrittura. Le operazioni di scrittura all’interno delle transazioni devono essere emesse implicitamente specificando la preoccupazione di scrittura. Le operazioni di scrittura vengono quindi impegnate utilizzando la preoccupazione di scrittura a livello di transazione.

È possibile impostare il problema di scrittura a livello di transazione su startTransaction (). Se la preoccupazione di scrittura a livello di transazione non è impostata, è impostata in modo predefinito alla preoccupazione per la scrittura a livello di sessione per il commit. Se sia le preoccupazioni di scrittura a livello di transazione che a livello di sessione sono non stabilite, la preoccupazione di scrittura a livello di transazione va automaticamente alla preoccupazione di scrittura a livello di client.

Gestione delle transazioni Java MongoDB

Gestire tutte le transazioni può essere un lavoro pesante, ma qui ci sono alcuni modi per gestire le transazioni. È possibile aggiungere il supporto delle transazioni utilizzando i dati Java Spring e i driver Java Mongo. Un’API del driver fa questo:

Try (ClientSession session = client.avvio ()) < session.startTransaction(); try < collection.insertOne(session, documentOne); collection.insertOne(session, documentTwo); session.commitTransaction(); >cattura (eccezione E) < session.abortTransaction(); >> 

Le sessioni del cliente ottenute dal cliente.avvio () dovrebbe essere di breve durata e rilasciata contemporaneamente quando non è più necessario. Pertanto, assicurarsi di includere il comando Close ().

Lo snippet sopra contiene la sessione (LSID) in ogni riga di comando. &lsquo;starttransaction&rsquo; viene inviato con il primo comando che rappresenta la transazione. E una volta completato, la transazione viene impegnata inviando &lsquo;impegno.&rsquo;

Le versioni precedenti di MongoDB non hanno supportato le transazioni, quindi la parte essenziale è configurare MongoTransactionManager nel tuo Context Application. Transaction Manager è un punto di ingresso per il supporto delle transazioni basato sull’annotazione. Per la configurazione, utilizzare il codice seguente:

@Configuration Class Config estende AbstractMongoconfiguration < @Bean MongoTransactionManager transactionManager(MongoDbFactory dbFactory) < return new MongoTransactionManager(dbFactory); >> @Service class documentservice < private final MongoOperations operations; DocumentService(MongoOperations operations) < this.operations = operations; >@Transactional void insertDocuments () < operations.insert(documentOne); operations.insert(documentTwo); >> 

Quello&rsquo;sedersi. Non c’è molto per la gestione delle transazioni Java MongoDB, quindi ci sono alcuni semplici passaggi da esaminare.

Flusso di lavoro delle transazioni Java Mongodb

Nella prima fase dell’utilizzo della transazione, è necessario iniziare una sessione MongoDB attraverso un driver. Questo articolo segue una sessione di MongoDB con il driver java mongodb. Quindi, utilizzare quella sessione per eseguire il gruppo di operazioni di database. È possibile eseguire qualsiasi operazione CRUD (Crea, Read, Update ed Elimina) su più documenti, raccolte e frammenti.

MongodB&rsquo;Le transazioni S hanno origini a nodo singolo-write, anche nel contesto di un singolo frammento. Il suo protocollo del motore di stoccaggio e della replica è sostituito per il percorso per le transazioni. Di seguito è riportata una figura che rappresenta un’app di e -commerce con 2 clienti MongoDB.

Qui, il client 1 esegue le transazioni e il client 2 legge un record aggiornato dalla transazione invocata dal client 1. Il client 1 inserisce un nuovo ordine nella raccolta degli ordini e aggiorna lo stock dell’articolo ordinato (supponendo che l’ordine venga spedito correttamente). Ora, l’unica preoccupazione di scrittura adatta per un’elevata durata dei dati è la maggior parte. La maggioranza significa la maggior parte delle repliche, io.e., La maggioranza delle repliche è commettere i cambiamenti prima che il primario riconosca il successo della scrittura al cliente.

La transazione verrà bloccata fino a quando almeno uno o due secondari estraggono l’aggiornamento dalla replica. Questo processo rende MongoDB&rsquo;La transazione Single-Shard scrive un po ‘più lento rispetto ad altri nosql transazionali.

Conclusione

Abbiamo camminato usando MongoDB in Java e la transazione&rsquo;S Creazione, Gestione e flusso di lavoro. L’uso delle transazioni Java MongoDB in database garantisce che un database detenga uno stato coerente dopo aver eseguito un gruppo di operazioni.

MongoDB ha adottato il funzionamento delle transazioni dai modelli transazionali più familiari implementati in MySQL, Oracle e in altri database relazionali acidi. Ironia della sorte, la funzionalità della modellazione dei dati MongoDB per i dati correlati da archiviare insieme in un unico documento sfrutta il modello di documento che non richiede transazioni multi-documento. Ma gli sviluppatori ammirano la flessibilità nel modellare i loro dati. Pertanto, esiste la funzione delle transazioni in mongodb.

I dati HEVO, una pipeline di dati senza codice, possono trasferire perfettamente i dati da un vasto mare di oltre 100 fonti come MongoDB e Atlante Mongodb a un data warehouse o una destinazione a tua scelta da visualizzare in uno strumento BI. È un servizio affidabile, completamente automatizzato e sicuro che non lo fa&rsquo;ti richiedi di scrivere qualsiasi codice!

Se stai usando MongoDB come sistema di gestione del database NoSQL E alla ricerca di un’alternativa senza confusione all’integrazione manuale dei dati, quindi Hevo può automatizzarlo senza sforzo per te. Hevo, con la sua forte integrazione con oltre 100 fonti e strumenti BI (Tra cui oltre 40 fonti gratuite), consente non solo di esportare e caricare i dati, ma anche di trasformare e arricchire i tuoi dati e renderli pronti per l’analisi in un jiffy.

Voglio prendere Hevo per un giro? Iscriviti per un Prova gratuita di 14 giorni e semplifica il processo di integrazione dei dati. Dai un’occhiata ai dettagli dei prezzi per capire quale piano soddisfa tutte le esigenze aziendali.

Parlaci della tua esperienza di apprendimento sul Transazione Java MongoDB! Condividi i tuoi pensieri con noi nella sezione commenti qui sotto.

MoneyLion funziona con varo? Il monopode è da solo?

Related Posts

Notizia

Vinyl suona bene su Sonos

Notizia

Fa Epson 4700 Print Cardstock

Notizia

Le cuffie ad alto volume di volume

banner
banner

PROMO

racavedigger.com
© racavedigger.com 2026