Creare un'app console Java con Azure Cosmos DB per MongoDB vCore

• .NET
• Pitone
• Node.js
• Giava
• Vai
• Ruggine

In questa guida si sviluppa un'applicazione console Java per connettersi a un cluster vCore di Azure Cosmos DB per MongoDB. La guida include i passaggi per configurare l'ambiente di sviluppo, eseguire l'autenticazione usando il azure-identity pacchetto di Azure SDK per Java e interagire con il database e la raccolta per gestire i documenti.

Prerequisiti

• Un cluster esistente di Azure Cosmos DB per MongoDB (vCore).

• Versione più recente dell'interfaccia della riga di comando di Azure in Azure Cloud Shell.

  • Se si preferisce eseguire i comandi CLI di riferimento in locale, accedere all'interfaccia della riga di comando di Azure usando il comando az login.

• Autenticazione di Microsoft Entra configurata per il cluster con il ruolo dbOwner assegnato alla tua identità.

  • Per abilitare l'autenticazione di Microsoft Entra, vedere la guida alla configurazione.

• Versione più recente di Java.

Configurare l'applicazione console

Creare quindi un nuovo progetto di applicazione console e importare le librerie necessarie per l'autenticazione nel cluster.

1. Creare un nuovo progetto Maven usando gli strumenti da riga di comando Maven.

   mvn archetype:generate -DgroupId=com.cosmicworks -DartifactId=mongodb-console-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
   

2. Vai alla directory del progetto.

   cd mongodb-console-app
   

3. Creare un nuovo file App.java con una Main classe nella directory del pacchetto appropriata.

   mkdir -p src/main/java/com/cosmicworks
   touch src/main/java/com/cosmicworks/App.java
   

4. Aggiungi la azure-identity dipendenza al file pom.xml.

   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-identity</artifactId>
       <version>1.15.4</version>
   </dependency>
   

5. Aggiungi la mongodb-driver-sync dipendenza al file pom.xml.

   <dependency>
       <groupId>org.mongodb</groupId>
       <artifactId>mongodb-driver-sync</artifactId>
       <version>5.4.0</version>
   </dependency>
   

Connettersi al cluster

Ora, utilizza la libreria Azure.Identity per ottenere un TokenCredential da utilizzare per connetterti al cluster. Il driver Ufficiale di MongoDB ha un'interfaccia speciale che deve essere implementata per ottenere i token da Microsoft Entra per l'uso durante la connessione al cluster.

1. Per iniziare, importare le classi necessarie nella parte superiore del file di classe Java.

   import java.util.concurrent.TimeUnit;
   
   import org.bson.Document;
   import org.bson.conversions.Bson;
   
   import com.azure.core.credential.TokenCredential;
   import com.azure.core.credential.TokenRequestContext;
   import com.azure.identity.DefaultAzureCredentialBuilder;
   import com.mongodb.MongoClientSettings;
   import com.mongodb.MongoCredential;
   import com.mongodb.MongoCredential.OidcCallbackContext;
   import com.mongodb.MongoCredential.OidcCallbackResult;
   import com.mongodb.client.MongoClient;
   import com.mongodb.client.MongoClients;
   import com.mongodb.client.MongoCollection;
   import com.mongodb.client.MongoDatabase;
   import com.mongodb.client.model.Filters;
   import com.mongodb.client.model.ReplaceOptions;
   import com.mongodb.client.result.UpdateResult;
   

2. Nel metodo Main, è necessario creare un'istanza di DefaultAzureCredential e impostare il callback OpenID Connect (OIDC) per recuperare i token.

   TokenCredential credential = new DefaultAzureCredentialBuilder().build();
   
   MongoCredential.OidcCallback oidcCallback = new MongoCredential.OidcCallback() {
       @Override
       public OidcCallbackResult onRequest(OidcCallbackContext context) {
           TokenRequestContext tokenRequestContext = new TokenRequestContext()
                   .addScopes("https://ossrdbms-aad.database.windows.net/.default");
           String token = credential.getTokenSync(tokenRequestContext).getToken();
           return new OidcCallbackResult(token);
       }
   };
   

3. Creare una nuova istanza di MongoCredential usando il callback definito in precedenza.

   MongoCredential mongoCredential = MongoCredential.createOidcCredential(null)
           .withMechanismProperty("OIDC_CALLBACK", oidcCallback);
   

4. Creare variabili per il nome del cluster e l'intero endpoint host.

   String clusterName = "<azure-cosmos-db-mongodb-vcore-cluster-name>";
   String host = clusterName + ".global.mongocluster.cosmos.azure.com";
   

5. Creare un'istanza MongoClientSettings usando l'host, le procedure consigliate per la connessione e le credenziali.

   MongoClientSettings settings = MongoClientSettings.builder()
           .applyToClusterSettings(builder -> builder
                   .srvHost(host))
           .applyToSocketSettings(builder -> builder
                   .connectTimeout(2, TimeUnit.MINUTES))
           .applyToSslSettings(builder -> builder
                   .enabled(true))
           .retryWrites(true)
           .credential(mongoCredential)
           .build();
   

6. Creare un nuovo MongoClient oggetto usando le impostazioni costruite.

   MongoClient client = MongoClients.create(settings);
   
   System.out.println("Client created");
   

Eseguire operazioni comuni

Infine, usare la libreria ufficiale per eseguire attività comuni con database, raccolte e documenti. In questo caso si usano le stesse classi e metodi usati per interagire con MongoDB o DocumentDB per gestire le raccolte e gli elementi.

1. Ottenere i riferimenti a database e collection.

   MongoDatabase database = client.getDatabase("<database-name>");
   
   System.out.println("Database pointer created");
   
   MongoCollection<Document> collection = database.getCollection("<collection-name>");
   
   System.out.println("Collection pointer created");
   

2. Rappresentare i documenti usando una Product classe .

   public class Product {
       private String _id;
       private String category;
       private String name;
       private int quantity;
       private double price;
       private boolean clearance;
   
       // Getters and setters ommitted for brevity
   }
   

3. Creare un nuovo documento usando collection.replaceOne con upsert abilitato.

   Document document = new Document()
           .append("_id", "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb")
           .append("category", "gear-surf-surfboards")
           .append("name", "Yamba Surfboard")
           .append("quantity", 12)
           .append("price", 850.00)
           .append("clearance", false);
   
   Bson match = Filters.eq("_id", "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb");
   
   ReplaceOptions options = new ReplaceOptions().upsert(true);
   UpdateResult result = collection.replaceOne(match, document, options);
   
   System.out.println("Document upserted with _id:\\t" + result.getUpsertedId().asString().getValue());
   

4. Eseguire una ricerca di un singolo documento usando collection.find e l'identificatore univoco.

   Bson filter = Filters.eq("_id", "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb");
   
   collection.find(filter).forEach(doc -> {
       System.out.println("Read document _id:\\t" + doc.toJson());
   });
   

5. Eseguire una query generale usando un filtro JSON binario (BSON).

   Bson query = Filters.eq("category", "gear-surf-surfboards");
   
   collection.find(query).forEach(doc -> {
       System.out.println("Found document:\\t" + doc.toJson());
   });
   

6. Eliminazione di documenti tramite un filtro e collection.deleteMany.

   Bson filter = Filters.eq("clearance", true);
   collection.deleteMany(filter);
   

Contenuti correlati

• Panoramica dell'autenticazione di Microsoft Entra
• Configurazione di Microsoft Entra per il cluster