Snabbstart: Använda Azure Cosmos DB för NoSQL med Azure SDK för Java

Artikel
2025-04-11
Gäller för: ✅ NoSQL

I den här snabbstarten distribuerar du ett grundläggande Azure Cosmos DB for NoSQL-program med hjälp av Azure SDK för Java. Azure Cosmos DB for NoSQL är ett schemalöst datalager som gör det möjligt för program att lagra ostrukturerade data i molnet. Fråga efter data i dina containrar och utför vanliga åtgärder på enskilda objekt med hjälp av Azure SDK för Java.

API-referensdokumentation | Bibliotekets källkod | Paket (Maven) | Azure Developer CLI

Förutsättningar

Azure Developer CLI
Docker Desktop
Java 21

Om du inte har något Azure-konto skapar du ett kostnadsfritt konto innan du börjar.

Initiera projektet

Använd Azure Developer CLI (azd) för att skapa ett Azure Cosmos DB för NoSQL-konto och distribuera ett containerbaserat exempelprogram. Exempelprogrammet använder klientbiblioteket för att hantera, skapa, läsa och fråga efter exempeldata.

Öppna en terminal i en tom katalog.
Om du inte redan är autentiserad autentiserar du till Azure Developer CLI med .azd auth login Följ stegen som anges av verktyget för att autentisera till CLI med dina önskade Azure-autentiseringsuppgifter.
```
azd auth login
```

Använd azd init för att initiera projektet.

azd init --template cosmos-db-nosql-java-quickstart

Under initieringen konfigurerar du ett unikt miljönamn.
Distribuera Azure Cosmos DB-kontot genom att använda azd up. Bicep-mallarna distribuerar också ett exempel på ett webbprogram.
```
azd up
```
Under etableringsprocessen väljer du din prenumeration, önskad plats och målresursgrupp. Vänta tills tilldelningen är klar. Processen kan ta ungefär fem minuter.

När etableringen av dina Azure-resurser är klar inkluderas en URL till det webbprogram som körs i utdata.

Deploying services (azd deploy)

  (✓) Done: Deploying service web
- Endpoint: <https://[container-app-sub-domain].azurecontainerapps.io>

SUCCESS: Your application was provisioned and deployed to Azure in 5 minutes 0 seconds.

Använd URL:en i konsolen för att navigera till webbprogrammet i webbläsaren. Observera utdata från appen som körs.

Skärmbild av webbprogrammet som körs.

Installera klientbiblioteket

Klientbiblioteket är tillgängligt via Maven som azure-spring-data-cosmos paket.

Gå till /src/web mappen och öppna filen pom.xml .

Om den inte redan finns lägger du till en post för azure-spring-data-cosmos paketet.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-spring-data-cosmos</artifactId>
</dependency>

Lägg också till ett annat beroende för azure-identity paketet om det inte redan finns.

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

Importera bibliotek

Importera alla nödvändiga namnområden till programkoden.

import com.azure.cosmos.CosmosClientBuilder;
import com.azure.cosmos.models.PartitionKey;
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.spring.data.cosmos.config.AbstractCosmosConfiguration;
import com.azure.spring.data.cosmos.config.CosmosConfig;
import com.azure.spring.data.cosmos.core.mapping.Container;
import com.azure.spring.data.cosmos.core.mapping.PartitionKey;
import com.azure.spring.data.cosmos.repository.CosmosRepository;
import com.azure.spring.data.cosmos.repository.Query;
import com.azure.spring.data.cosmos.repository.config.EnableCosmosRepositories;

Objektmodell

Namn	beskrivning
`EnableCosmosRepositories`	Den här typen är en metoddekoratör som används för att konfigurera en lagringsplats för åtkomst till Azure Cosmos DB för NoSQL.
`CosmosRepository`	Den här klassen är den primära klientklassen och används för att hantera data i en container.
`CosmosClientBuilder`	Den här klassen är en fabrik som används för att skapa en klient som används av lagringsplatsen.
`Query`	Den här typen är en metoddekoratör som används för att ange queryn som lagringsplatsen kör.

Exempelkoden i mallen använder en databas med namnet cosmicworks och containern med namnet products. Containern products innehåller information som namn, kategori, kvantitet, en unik identifierare och en försäljningsflagga för varje produkt. Containern använder egenskapen /category som en logisk partitionsnyckel.

Autentisera klienten

Först skapar det här exemplet en ny klass som ärver från AbstractCosmosConfiguration för att konfigurera anslutningen till Azure Cosmos DB för NoSQL.

@Configuration
@EnableCosmosRepositories
public class CosmosConfiguration extends AbstractCosmosConfiguration {
}

I konfigurationsklassen skapar exemplet en ny instans av CosmosClientBuilder-klassen och konfigurerar autentisering med hjälp av en CosmosClientBuilder och en instans.

@Bean
public CosmosClientBuilder getCosmosClientBuilder() {
    DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
        .build();
        
    return new CosmosClientBuilder()
        .endpoint("<azure-cosmos-db-nosql-account-endpoint>")
        .credential(credential);
}

Hämta en databas

I konfigurationsklassen implementerar exemplet en metod för att returnera namnet på den befintliga databasen med namnet cosmicworks.

@Override
protected String getDatabaseName() {
    return "cosmicworks";
}

Hämta en container

Använd metoddekoratören Container för att konfigurera en klass för att representera objekt i en container. Skapa klassen för att inkludera alla medlemmar som du vill serialisera i JSON. I det här exemplet har typen en unik identifierare och fält för kategori, namn, kvantitet, pris och klarering.

@Container(containerName = "products", autoCreateContainer = false)
public class Item {
    private String id;
    private String name;
    private Integer quantity;
    private Boolean sale;

    @PartitionKey
    private String category;

    // Extra members omitted for brevity
}

Skapa ett objekt

Skapa ett objekt i containern med .repository.save

Item item = new Item(
    "aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb",
    "gear-surf-surfboards",
    "Yamba Surfboard",
    12,
    false
);
Item created_item = repository.save(item);

Läsa ett objekt

Utför en punktläsningsåtgärd med hjälp av både de unika identifierarna (id) och partitionsnyckelfälten. Använd repository.findById för att effektivt hämta det specifika objektet.

PartitionKey partitionKey = new PartitionKey("gear-surf-surfboards");
Optional<Item> existing_item = repository.findById("aaaaaaaa-0000-1111-2222-bbbbbbbbbbbb", partitionKey);
if (existing_item.isPresent()) {
    // Do something
}

Frågeobjekt

Utför en fråga över flera objekt i en container genom att definiera en fråga i lagringsplatsens gränssnitt. Det här exemplet använder metoddekoratören Query för att definiera en metod som kör den här parameteriserade frågan:

SELECT * FROM products p WHERE p.category = @category

@Repository
public interface ItemRepository extends CosmosRepository<Item, String> {

    @Query("SELECT * FROM products p WHERE p.category = @category")
    List<Item> getItemsByCategory(@Param("category") String category);

}

Hämta alla resultat av sökfrågan med hjälp av repository.getItemsByCategory. Loopa igenom resultatet av frågan.

List<Item> items = repository.getItemsByCategory("gear-surf-surfboards");
for (Item item : items) {
    // Do something
}

Utforska dina data

Använd Visual Studio Code-tillägget för Azure Cosmos DB för att utforska dina NoSQL-data. Du kan utföra grundläggande databasåtgärder, inklusive, men inte begränsat till:

Utföra frågor med hjälp av en scrapbook eller frågeredigeraren
Ändra, uppdatera, skapa och ta bort objekt
Importera massdata från andra källor
Hantera databaser och containrar

Mer information finns i Använda Visual Studio Code-tillägget för att utforska Azure Cosmos DB för NoSQL-data.

Rensa resurser

När du inte längre behöver exempelprogrammet eller resurserna tar du bort motsvarande distribution och alla resurser.

azd down

Dela via