Partilhar via

Constrói uma aplicação de consola Java com o Azure DocumentDB

Neste guia, desenvolve uma aplicação de consola Java para se ligar a um cluster 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 do Azure DocumentDB existente

  • Autenticação do Microsoft Entra configurada para o cluster com o papel atribuído à sua identidade root.

  • 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 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 de 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 azure-identity dependência ao seu arquivo pom.xml .

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

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

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

Ligar ao cluster

Agora, use a Azure.Identity biblioteca para obter um TokenCredential para usar para se conectar ao seu 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 seu 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 de DefaultAzureCredential e configure o callback do OpenID Connect (OIDC) para obter 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 a sua função de retorno definida anteriormente.

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

  4. Crie variáveis para o nome do cluster e o ponto de extremidade 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 novo MongoClient usando as configurações definidas.

    MongoClient client = MongoClients.create(settings);

System.out.println("Client created");

Executar operações comuns

Finalmente, 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 o MongoDB ou o Banco de Dados de Documentos para gerenciar suas coleções e itens.

  1. Obtenha referências ao 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 com o collection.replaceOne ativado usando .

    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 JSON binário (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 usando um filtro e collection.deleteMany.

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

Conteúdo relacionado

  • Last updated on