Criar um aplicativo de console Java com o Azure DocumentDB

Neste guia, você desenvolve um aplicativo de console Java para se conectar a um cluster do Azure DocumentDB. O guia inclui etapas para configurar seu ambiente de desenvolvimento, autenticar usando o azure-identity pacote do SDK do Azure para Java e interagir com o banco de dados e a coleção para gerenciar documentos.

Pré-requisitos

• Uma assinatura do Azure

  • Se você não tiver uma assinatura do Azure, crie uma conta gratuita

• Um cluster existente do Azure DocumentDB

  • Se você não tiver um cluster, crie um novo cluster

• Utilize o ambiente Bash no Azure Cloud Shell. Para obter mais informações, confira Introdução ao Azure Cloud Shell.

  

• Se você preferir executar comandos de referência da CLI localmente, instale a CLI do Azure. Se você estiver executando no Windows ou no macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, confira Como executar a CLI do Azure em um contêiner do Docker.

  • Se você estiver usando uma instalação local, entre na CLI do Azure usando o comando az login . Para concluir o processo de autenticação, siga as etapas exibidas em seu terminal. Para obter outras opções de entrada, consulte Autenticar no Azure usando a CLI do Azure.

  • Quando solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar e gerenciar extensões com a CLI do Azure.

  • Execute o comando az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

• Autenticação do Microsoft Entra configurada para o cluster com sua identidade concedida à função root.

  • Para habilitar a autenticação do Microsoft Entra, examine o guia de configuração.

• Versão mais recente do Java.

Configurar seu aplicativo de console

Em seguida, crie um novo projeto de aplicativo de console e importe as bibliotecas necessárias para autenticar no cluster.

1. Crie um novo projeto Maven usando as ferramentas de linha de comando do Maven.

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

2. Navegue até o diretório do projeto.

   cd mongodb-console-app
   

3. Crie um novo arquivo App.java com uma Main classe no diretório de pacote apropriado.

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

4. Adicione a dependência azure-identity ao seu arquivo pom.xml.

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

5. Adicione a dependência mongodb-driver-sync ao seu arquivo pom.xml.

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

Conectar-se ao cluster

Agora, use a biblioteca Azure.Identity para obter uma TokenCredential a ser usada para conectar-se ao cluster. O driver oficial do MongoDB tem uma interface especial que deve ser implementada para obter tokens do Microsoft Entra para uso ao se conectar ao cluster.

1. Comece importando as classes necessárias na parte superior do arquivo de 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. No seu método principal, crie uma instância DefaultAzureCredential e configure o retorno de chamada do OpenID Connect (OIDC) para buscar 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. Crie uma nova instância de MongoCredential usando seu retorno de chamada definido anteriormente.

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

4. Crie variáveis para o nome do cluster e o endpoint completo do host.

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

5. Construa uma MongoClientSettings instância usando o host, as práticas recomendadas de conexão e a 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. Crie um MongoClient usando as configurações construídas.

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

Executar operações comuns

Por fim, use a biblioteca oficial para executar tarefas comuns com bancos de dados, coleções e documentos. Aqui, você usa as mesmas classes e métodos que usaria para interagir com MongoDB ou DocumentDB para gerenciar suas coleções e itens.

1. Obtenha referências para o seu 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. Represente seus documentos usando uma 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. Crie um novo documento collection.replaceOne com 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. Execute uma pesquisa de um único documento usando collection.find e o identificador exclusivo.

   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. Execute uma consulta geral usando um filtro BSON (JSON) binário.

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

6. Excluir documentos usando um filtro e collection.deleteMany.

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

Conteúdo relacionado

• Visão geral da autenticação do Microsoft Entra
• Configuração do Microsoft Entra para clusters