Skapa en Java-konsolapp med Azure DocumentDB

I den här guiden utvecklar du ett Java-konsolprogram för att ansluta till ett Azure DocumentDB-kluster. Guiden innehåller steg för att konfigurera utvecklingsmiljön, autentisera azure-identity med paketet från Azure SDK för Java och interagera med databasen och samlingen för att hantera dokument.

Förutsättningar

En prenumeration på Azure
- Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto

Ett befintligt Azure DocumentDB-kluster
- Om du inte har något kluster skapar du ett nytt kluster

Använd Bash-miljön i Azure Cloud Shell. Mer information finns i Kom igång med Azure Cloud Shell.
Om du föredrar att köra CLI-referenskommandon lokalt installerar du Azure CLI. Om du kör på Windows eller macOS, överväg att köra Azure CLI i en Docker-container. För mer information, se Hur man kör Azure CLI i en Docker-container.
- Om du använder en lokal installation loggar du in på Azure CLI med hjälp av kommandot az login. För att avsluta autentiseringsprocessen, följ stegen som visas i din terminal. Andra inloggningsalternativ finns i Autentisera till Azure med Azure CLI.
- När du blir uppmanad, installera Azure CLI-tillägget vid första användning. Mer information om tillägg finns i Använda och hantera tillägg med Azure CLI.
- Kör az version för att ta reda på versionen och de beroende bibliotek som är installerade. Om du vill uppgradera till den senaste versionen kör du az upgrade.

Microsoft Entra-autentisering har konfigurerats för klustret och din identitet har tilldelats root roll.
- Om du vill aktivera Microsoft Entra-autentisering läser du konfigurationsguiden.
Senaste versionen av Java.

Konfigurera konsolprogrammet

Skapa sedan ett nytt konsolprogramprojekt och importera de bibliotek som behövs för att autentisera till klustret.

Skapa ett nytt Maven-projekt med hjälp av maven-kommandoradsverktygen.

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

Gå till projektkatalogen.
```
cd mongodb-console-app
```

Skapa en ny App.java fil med en Main klass i lämplig paketkatalog.

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

Lägg till azure-identity beroendet i din pom.xml-fil.

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

Lägg till mongodb-driver-sync beroendet i din pom.xml-fil.

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

Anslut till klustret

Använd nu Azure.Identity biblioteket för att få en TokenCredential som du kan använda för att ansluta till din kluster. Den officiella MongoDB-drivrutinen har ett särskilt gränssnitt som måste implementeras för att hämta token från Microsoft Entra för användning vid anslutning till klustret.

Börja med att importera de klasser som krävs överst i Java-klassfilen.

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;

I huvudmetoden skapar du en DefaultAzureCredential instans och konfigurerar återanropet OpenID Connect (OIDC) för att hämta 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);
    }
};

Skapa en ny instans av MongoCredential genom att använda ditt tidigare definierade återanrop.

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

Skapa variabler för namnet på klustret och hela värdslutpunkten.

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

Konstruera en MongoClientSettings instans med hjälp av värden, bästa anslutningsmetoder och autentiseringsuppgifterna.

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();

Skapa en ny MongoClient med hjälp av de konstruerade inställningarna.

MongoClient client = MongoClients.create(settings);

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

Utföra vanliga åtgärder

Använd slutligen det officiella biblioteket för att utföra vanliga uppgifter med databaser, samlingar och dokument. Här använder du samma klasser och metoder som du skulle använda för att interagera med MongoDB eller DocumentDB för att hantera dina samlingar och objekt.

Hämta referenser till ditt database och 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");

Representera dina dokument med hjälp av en Product klass.

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
}

Skapa ett nytt dokument med collection.replaceOneupsert aktiverat.

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());

Utför en sökning av ett enskilt dokument med collection.find och den unika identifieraren.

Bson filter = Filters.eq("_id", "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb");

collection.find(filter).forEach(doc -> {
    System.out.println("Read document _id:\\t" + doc.toJson());
});

Utför en allmän fråga med ett binärt JSON-filter (BSON).

Bson query = Filters.eq("category", "gear-surf-surfboards");

collection.find(query).forEach(doc -> {
    System.out.println("Found document:\\t" + doc.toJson());
});

Ta bort dokument med hjälp av ett filter och collection.deleteMany.

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

Feedback

Var den här sidan till hjälp?

Last updated on 2025-11-19