Udostępnij za pomocą

Tworzenie aplikacji konsolowej Java przy użyciu usługi Azure DocumentDB

W tym przewodniku utworzysz aplikację konsolową Java w celu nawiązania połączenia z klastrem usługi Azure DocumentDB. Ten przewodnik zawiera kroki konfigurowania środowiska deweloperskiego, uwierzytelniania przy użyciu azure-identity pakietu z zestawu Azure SDK dla języka Java oraz interakcji z bazą danych i kolekcją w celu zarządzania dokumentami.

Wymagania wstępne

  • Subskrypcja platformy Azure

  • Istniejący klaster usługi Azure DocumentDB

  • Uwierzytelnianie Microsoft Entra zostało skonfigurowane dla klastra z przypisaną rolą dla Twojej tożsamości root.

  • Najnowsza wersja języka Java.

Konfigurowanie aplikacji konsolowej

Następnie utwórz nowy projekt aplikacji konsolowej i zaimportuj niezbędne biblioteki do uwierzytelniania w klastrze.

  1. Utwórz nowy projekt Maven przy użyciu narzędzi wiersza polecenia narzędzia Maven.

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

  2. Przejdź do katalogu projektu.

    cd mongodb-console-app

  3. Utwórz nowy plik App.java z klasą Main w odpowiednim katalogu pakietów.

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

  4. Dodaj zależność azure-identity do pliku pom.xml.

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

  5. Dodaj zależność mongodb-driver-sync do pliku pom.xml.

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

Połącz się z klastrem

Teraz użyj biblioteki Azure.Identity, aby uzyskać TokenCredential, którego możesz użyć do połączenia się z klastrem. Oficjalny sterownik bazy danych MongoDB ma specjalny interfejs, który należy zaimplementować w celu uzyskania tokenów z firmy Microsoft Entra do użycia podczas nawiązywania połączenia z klastrem.

  1. Zacznij od zaimportowania wymaganych klas na początku pliku klasy 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. W metodzie głównej utwórz wystąpienie DefaultAzureCredential i skonfiguruj procedurę zwrotu OpenID Connect (OIDC), aby pozyskać tokeny.

    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. Utwórz nowe wystąpienie przy użyciu wcześniej zdefiniowanego wywołania zwrotnego MongoCredential.

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

  4. Utwórz zmienne dla nazwy klastra i całego punktu końcowego hosta.

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

  5. Skonstruuj MongoClientSettings wystąpienie przy użyciu hosta, najlepszych rozwiązań dotyczących połączeń i poświadczeń.

    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. Utwórz nową MongoClient przy użyciu skonstruowanych ustawień.

    MongoClient client = MongoClients.create(settings);

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

Wykonywanie typowych operacji

Na koniec użyj oficjalnej biblioteki do wykonywania typowych zadań z bazami danych, kolekcjami i dokumentami. W tym miejscu użyjesz tych samych klas i metod, których należy użyć do interakcji z bazą danych MongoDB lub DocumentDB w celu zarządzania kolekcjami i elementami.

  1. Pobierz odwołania do swoich database i 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. Reprezentuj dokumenty za pomocą klasy Product.

    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. Utwórz nowy dokument przy użyciu collection.replaceOne z włączoną funkcją upsert.

    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. Przeprowadź wyszukiwanie pojedynczego dokumentu za pomocą collection.find i unikatowego identyfikatora.

    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. Wykonaj zapytanie ogólne przy użyciu filtru binarnego JSON (BSON).

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

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

  6. Usuwanie dokumentów przy użyciu filtru i collection.deleteMany.

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

Treści powiązane

  • Last updated on