Compilación de una aplicación de consola de Java con Azure DocumentDB

• .NET
• Python
• Node.js
• Java
• Ir a
• Óxido

En esta guía, desarrollará una aplicación de consola de Java para conectarse a un clúster de Azure DocumentDB. La guía incluye pasos para configurar el entorno de desarrollo, autenticarse mediante el azure-identity paquete del SDK de Azure para Java e interactuar con la base de datos y la colección para administrar documentos.

Prerrequisitos

• Una suscripción de Azure

  • Si no tiene ninguna suscripción a Azure, cree una cuenta gratuita

• Un clúster de Azure DocumentDB existente

  • Si no tiene un clúster, cree un nuevo clúster.

• Use el entorno de Bash en Azure Cloud Shell. Para más información, consulte Introducción a Azure Cloud Shell.

  

• Si prefieres ejecutar comandos de referencia CLI localmente, instala la CLI de Azure. Si estás utilizando Windows o macOS, considera ejecutar Azure CLI en un contenedor Docker. Para obtener más información, consulte Cómo ejecutar el Azure CLI en un contenedor de Docker.

  • Si estás utilizando una instalación local, inicia sesión en Azure CLI utilizando el comando az login. Siga los pasos que se muestran en el terminal para completar el proceso de autenticación. Para ver otras opciones de inicio de sesión, consulte Autenticación en Azure mediante la CLI de Azure.

  • En caso de que se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para obtener más información sobre las extensiones, consulte Uso y administración de extensiones con la CLI de Azure.

  • Ejecute az version para ver la versión y las bibliotecas dependientes que están instaladas. Para actualizar a la versión más reciente, ejecute az upgrade.

• La autenticación de Microsoft Entra está configurada para el clúster con el rol root concedido a la identidad.

  • Para habilitar la autenticación de Microsoft Entra, revise la guía de configuración.

• Versión más reciente de Java.

Configuración de la aplicación de consola

A continuación, cree un nuevo proyecto de aplicación de consola e importe las bibliotecas necesarias para autenticarse en el clúster.

1. Cree un nuevo proyecto de Maven mediante las herramientas de línea de comandos de Maven.

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

2. Vaya al directorio del proyecto.

   cd mongodb-console-app
   

3. Cree un nuevo archivo App.java con una Main clase en el directorio de paquetes adecuado.

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

4. Agregue la dependencia azure-identity al archivo pom.xml.

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

5. Agregue la dependencia mongodb-driver-sync al archivo pom.xml.

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

Conectarse al clúster

Ahora, utilice la Azure.Identity biblioteca para obtener un TokenCredential que usará para conectarse a su clúster. El controlador oficial de MongoDB tiene una interfaz especial que se debe implementar para obtener tokens de Microsoft Entra para su uso al conectarse al clúster.

1. Empiece por importar las clases necesarias en la parte superior del archivo de clase 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. En el método principal, cree una instancia DefaultAzureCredential y configure la devolución de llamada de OpenID Connect (OIDC) para capturar tokens.

   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. Crea una nueva instancia de MongoCredential utilizando la función de devolución de llamada definida anteriormente.

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

4. Cree variables para el nombre del clúster y el punto de conexión de host completo.

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

5. Construya una MongoClientSettings instancia mediante el host, los procedimientos recomendados de conexión y la credencial.

   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. Cree un nuevo MongoClient con los ajustes establecidos.

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

Realización de operaciones comunes

Por último, use la biblioteca oficial para realizar tareas comunes con bases de datos, colecciones y documentos. Aquí, usará las mismas clases y métodos que usaría para interactuar con MongoDB o DocumentDB para administrar las colecciones y los elementos.

1. Obtenga referencias a su database y 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. Represente los documentos mediante una Product clase .

   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. Cree un nuevo documento mediante collection.replaceOne con upsert habilitado.

   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. Realice una búsqueda de un único documento mediante collection.find y el identificador único.

   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. Realice una consulta general mediante 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. Eliminar documentos mediante un filtro y collection.deleteMany.

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

Contenido relacionado

• Información general sobre la autenticación de Microsoft Entra
• Configuración de Microsoft Entra para el clúster