Pemrograman DynamoDB dengan AWS SDK for Java 2.x - Amazon DynamoDB
Tentang AWS SDK for Java 2.xMemulaiDokumentasi SDK for Java 2.xAntarmuka yang didukungContoh kode tambahanSinkronisasi dan pemrograman asyncKlien HTTPConfigPenanganan kesalahanAWS ID permintaanPencatatan logPaginasiAnotasi kelas data

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Pemrograman DynamoDB dengan AWS SDK for Java 2.x

Panduan pemrograman ini memberikan orientasi bagi programmer yang ingin menggunakan Amazon DynamoDB dengan Java. Panduan ini mencakup konsep yang berbeda termasuk lapisan abstraksi, manajemen konfigurasi, penanganan kesalahan, pengendalian kebijakan coba lagi, dan pengelolaan keep-alive.

Tentang AWS SDK for Java 2.x

Anda dapat mengakses DynamoDB dari Java menggunakan resmi. AWS SDK for Java SDK for Java memiliki dua versi: 1.x dan 2.x. end-of-support Untuk 1.x diumumkan pada 12 Januari 2024. Ini akan memasuki mode pemeliharaan pada 31 Juli 2024 dan akan jatuh tempo pada 31 Desember 2025. end-of-support Untuk pengembangan baru, kami sangat menyarankan Anda menggunakan 2.x, yang pertama kali dirilis pada tahun 2018. Panduan ini secara eksklusif menargetkan 2.x dan hanya berfokus pada bagian SDK yang relevan dengan DynamoDB.

Untuk informasi tentang pemeliharaan dan dukungan untuk AWS SDK, lihat Kebijakan pemeliharaan AWS SDK dan Alat serta AWS matriks dukungan versi SDK dan Alat di Panduan Referensi AWS SDK dan Alat.

AWS SDK for Java 2.x Ini adalah penulisan ulang utama dari basis kode 1.x. SDK for Java 2.x mendukung fitur Java modern, seperti I/O non-blocking yang diperkenalkan di Java 8. SDK for Java 2.x juga menambahkan dukungan untuk implementasi klien HTTP pluggable untuk memberikan lebih banyak fleksibilitas koneksi jaringan dan opsi konfigurasi.

Perubahan nyata antara SDK for Java 1.x dan SDK for Java 2.x adalah penggunaan nama paket baru. Java 1.x SDK menggunakan nama com.amazonaws paket, sedangkan Java 2.x SDK menggunakan. software.amazon.awssdk Demikian pula, artefak Maven untuk Java 1.x SDK menggunakan com.amazonawsgroupId, sedangkan artefak Java 2.x SDK menggunakan file. software.amazon.awssdk groupId

penting

AWS SDK for Java 1.x memiliki paket DynamoDB bernama. com.amazonaws.dynamodbv2 “v2" dalam nama paket tidak menunjukkan bahwa itu untuk Java 2 (J2SE). Sebaliknya, “v2" menunjukkan bahwa paket mendukung versi kedua API tingkat rendah DynamoDB alih-alih versi asli API tingkat rendah.

Support untuk versi Java

AWS SDK for Java 2.x Ini memberikan dukungan penuh untuk rilis Java dukungan jangka panjang (LTS).

Memulai dengan AWS SDK for Java 2.x

Tutorial berikut menunjukkan cara menggunakan Apache Maven untuk mendefinisikan dependensi untuk SDK for Java 2.x. Tutorial ini juga menunjukkan cara menulis kode yang menghubungkan ke DynamoDB untuk daftar tabel DynamoDB yang tersedia. Tutorial dalam panduan ini didasarkan pada tutorial Memulai dengan AWS SDK for Java 2.x di Panduan AWS SDK for Java 2.x Pengembang. Kami telah mengedit tutorial ini untuk melakukan panggilan ke DynamoDB alih-alih Amazon S3.

Langkah 1: Siapkan tutorial ini

Sebelum Anda memulai tutorial ini, Anda memerlukan yang berikut:

  • Izin untuk mengakses DynamoDB.

  • Lingkungan pengembangan Java yang dikonfigurasi dengan akses masuk tunggal untuk Layanan AWS menggunakan file. Portal akses AWS

Untuk mengatur tutorial ini, ikuti petunjuk di Ikhtisar pengaturan di Panduan AWS SDK for Java 2.x Pengembang. Setelah Anda mengkonfigurasi lingkungan pengembangan Anda dengan akses masuk tunggal untuk Java SDK dan Anda memiliki sesi portal AWS akses aktif, kemudian lanjutkan ke Langkah 2 dari tutorial ini.

Langkah 2: Buat proyek

Untuk membuat proyek untuk tutorial ini, Anda menjalankan perintah Maven yang meminta Anda untuk masukan tentang cara mengkonfigurasi proyek. Setelah semua input dimasukkan dan dikonfirmasi, Maven selesai membangun proyek dengan membuat pom.xml file dan membuat file Java rintisan.

  1. Buka terminal atau jendela prompt perintah dan arahkan ke direktori pilihan Anda, misalnya, Home folder Anda Desktop atau.

  2. Masukkan perintah berikut di terminal, lalu tekan Enter.

    mvn archetype:generate \
   -DarchetypeGroupId=software.amazon.awssdk \
   -DarchetypeArtifactId=archetype-app-quickstart \
   -DarchetypeVersion=2.22.0

  3. Untuk setiap prompt, masukkan nilai yang tercantum di kolom kedua.

    Prompt Nilai untuk masuk
    Define value for property 'service': dynamodb
    Define value for property 'httpClient': apache-client
    Define value for property 'nativeImage': false
    Define value for property 'credentialProvider' identity-center
    Define value for property 'groupId': org.example
    Define value for property 'artifactId': getstarted
    Define value for property 'version' 1.0-SNAPSHOT: <Enter>
    Define value for property 'package' org.example: <Enter>

  4. Setelah Anda memasukkan nilai terakhir, Maven mencantumkan pilihan yang Anda buat. Untuk mengonfirmasi, masukkan Y. Atau, masukkan N, lalu masukkan kembali pilihan Anda.

Maven membuat folder proyek bernama getstarted berdasarkan artifactId nilai yang Anda masukkan. Di dalam getstarted folder, temukan file bernama README.md yang dapat Anda tinjau, pom.xml file, dan src direktori.

Maven membangun pohon direktori berikut.

getstarted
 ├── README.md
 ├── pom.xml
 └── src
     ├── main
     │   ├── java
     │   │   └── org
     │   │       └── example
     │   │           ├── App.java
     │   │           ├── DependencyFactory.java
     │   │           └── Handler.java
     │   └── resources
     │       └── simplelogger.properties
     └── test
         └── java
             └── org
                 └── example
                     └── HandlerTest.java
 
 10 directories, 7 files

Berikut ini menunjukkan isi dari file pom.xml proyek.

dependencyManagementBagian ini berisi ketergantungan ke AWS SDK for Java 2.x, dan dependencies bagian memiliki ketergantungan untuk DynamoDB. Menentukan dependensi ini memaksa Maven untuk menyertakan .jar file yang relevan di jalur kelas Java Anda. Secara default, AWS SDK tidak menyertakan semua kelas untuk semua Layanan AWS. Untuk DynamoDB, jika Anda menggunakan antarmuka tingkat rendah, maka Anda harus memiliki ketergantungan pada artefak. dynamodb Atau, jika Anda menggunakan antarmuka tingkat tinggi, pada dynamodb-enhanced artefak. Jika Anda tidak menyertakan dependensi yang relevan, maka kode Anda tidak dapat dikompilasi. Proyek ini menggunakan Java 1.8 karena 1.8 nilai dalam maven.compiler.source dan maven.compiler.target properti.

<?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>org.example</groupId>
     <artifactId>getstarted</artifactId>
     <version>1.0-SNAPSHOT</version>
     <packaging>jar</packaging>
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <maven.compiler.source>1.8</maven.compiler.source>
         <maven.compiler.target>1.8</maven.compiler.target>
         <maven.shade.plugin.version>3.2.1</maven.shade.plugin.version>
         <maven.compiler.plugin.version>3.6.1</maven.compiler.plugin.version>
         <exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
         <aws.java.sdk.version>2.22.0</aws.java.sdk.version> <-------- SDK version picked up from archetype version.
         <slf4j.version>1.7.28</slf4j.version>
         <junit5.version>5.8.1</junit5.version>
     </properties>
 
     <dependencyManagement>
         <dependencies>
             <dependency>
                 <groupId>software.amazon.awssdk</groupId>
                 <artifactId>bom</artifactId>
                 <version>${aws.java.sdk.version}</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
         </dependencies>
     </dependencyManagement>
 
     <dependencies>
         <dependency>
             <groupId>software.amazon.awssdk</groupId>
             <artifactId>dynamodb</artifactId>  <-------- DynamoDB dependency
             <exclusions>
                 <exclusion>
                     <groupId>software.amazon.awssdk</groupId>
                     <artifactId>netty-nio-client</artifactId>
                 </exclusion>
                 <exclusion>
                     <groupId>software.amazon.awssdk</groupId>
                     <artifactId>apache-client</artifactId>
                 </exclusion>
             </exclusions>
         </dependency>
 
         <dependency>
             <groupId>software.amazon.awssdk</groupId>
             <artifactId>sso</artifactId> <-------- Required for identity center authentication.
         </dependency>
 
         <dependency>
             <groupId>software.amazon.awssdk</groupId>
             <artifactId>ssooidc</artifactId> <-------- Required for identity center authentication.
         </dependency>
 
         <dependency>
             <groupId>software.amazon.awssdk</groupId>
             <artifactId>apache-client</artifactId> <-------- HTTP client specified.
             <exclusions>
                 <exclusion>
                     <groupId>commons-logging</groupId>
                     <artifactId>commons-logging</artifactId>
                 </exclusion>
             </exclusions>
         </dependency>
 
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
             <version>${slf4j.version}</version>
         </dependency>
 
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-simple</artifactId>
             <version>${slf4j.version}</version>
         </dependency>
 
         <!-- Needed to adapt Apache Commons Logging used by Apache HTTP Client to Slf4j to avoid
         ClassNotFoundException: org.apache.commons.logging.impl.LogFactoryImpl during runtime -->
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>jcl-over-slf4j</artifactId>
             <version>${slf4j.version}</version>
         </dependency>
 
         <!-- Test Dependencies -->
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
             <version>${junit5.version}</version>
             <scope>test</scope>
         </dependency>
     </dependencies>
 
     <build>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>${maven.compiler.plugin.version}</version>
             </plugin>
         </plugins>
     </build>
 
 </project>

Langkah 3: Tulis kodenya

Kode berikut menunjukkan App kelas yang dibuat Maven. mainMetode ini adalah titik masuk ke dalam aplikasi, yang menciptakan sebuah instance dari Handler kelas dan kemudian memanggil sendRequest metodenya.

package org.example;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class App {
     private static final Logger logger = LoggerFactory.getLogger(App.class);
 
     public static void main(String... args) {
         logger.info("Application starts");
 
         Handler handler = new Handler();
         handler.sendRequest();
 
         logger.info("Application ends");
     }
 }

DependencyFactoryKelas yang dibuat Maven berisi metode dynamoDbClient pabrik yang membangun dan mengembalikan sebuah instance. DynamoDbClient DynamoDbClientInstance menggunakan instance dari klien HTTP berbasis Apache. Ini karena Anda menentukan apache-client kapan Maven meminta Anda untuk klien HTTP mana yang akan digunakan.

Kode berikut menunjukkan DependencyFactory kelas.

package org.example;
 
 import software.amazon.awssdk.http.apache.ApacheHttpClient;
 import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
 
 /**
  * The module containing all dependencies required by the {@link Handler}.
  */
 public class DependencyFactory {
 
     private DependencyFactory() {}
 
     /**
      * @return an instance of DynamoDbClient
      */
     public static DynamoDbClient dynamoDbClient() {
         return DynamoDbClient.builder()
                        .httpClientBuilder(ApacheHttpClient.builder())
                        .build();
     }
 }

HandlerKelas berisi logika utama program Anda. Ketika sebuah instance Handler dibuat di App kelas, DependencyFactory melengkapi klien DynamoDbClient layanan. Kode Anda menggunakan DynamoDbClient instance untuk memanggil DynamoDB.

Maven menghasilkan Handler kelas berikut dengan komentar. TODO Langkah selanjutnya dalam tutorial menggantikan TODOkomentar dengan kode.

package org.example;
 
 import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
 
 
 public class Handler {
     private final DynamoDbClient dynamoDbClient;
 
     public Handler() {
         dynamoDbClient = DependencyFactory.dynamoDbClient();
     }
 
     public void sendRequest() {
         // TODO: invoking the API calls using dynamoDbClient.
     }
 }

Untuk mengisi logika, ganti seluruh isi Handler kelas dengan kode berikut. sendRequestMetode diisi dan impor yang diperlukan ditambahkan.

Kode berikut menggunakan DynamoDbClientcontoh untuk mengambil daftar tabel yang ada. Jika tabel ada untuk akun tertentu dan Wilayah AWS, maka kode menggunakan Logger instance untuk mencatat nama-nama tabel ini.

package org.example;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
 import software.amazon.awssdk.services.dynamodb.model.ListTablesResponse;
 
 
 public class Handler {
     private final DynamoDbClient dynamoDbClient;
 
     public Handler() {
         dynamoDbClient = DependencyFactory.dynamoDbClient();
     }
 
     public void sendRequest() {
         Logger logger = LoggerFactory.getLogger(Handler.class);
 
         logger.info("calling the DynamoDB API to get a list of existing tables");
         ListTablesResponse response = dynamoDbClient.listTables();
 
         if (!response.hasTableNames()) {
             logger.info("No existing tables found for the configured account & region");
         } else {
             response.tableNames().forEach(tableName -> logger.info("Table: " + tableName));
         }
     }
 }

Langkah 4: Bangun dan jalankan aplikasi

Setelah Anda membuat proyek dan berisi Handler kelas lengkap, membangun dan menjalankan aplikasi.

  1. Pastikan Anda memiliki AWS IAM Identity Center sesi aktif. Untuk mengonfirmasi, jalankan perintah AWS Command Line Interface (AWS CLI) aws sts get-caller-identity dan periksa responsnya. Jika Anda tidak memiliki sesi aktif, lihat Masuk menggunakan AWS CLI petunjuk.

  2. Buka terminal atau jendela prompt perintah dan arahkan ke direktori proyek Andagetstarted.

  3. Untuk membangun proyek Anda, jalankan perintah berikut:

    mvn clean package

  4. Untuk menjalankan aplikasi, jalankan perintah berikut:

    mvn exec:java -Dexec.mainClass="org.example.App"

Setelah Anda melihat file, hapus objek, dan kemudian hapus ember.

Berhasil

Jika proyek Maven Anda dibangun dan berjalan tanpa kesalahan, maka selamat! Anda telah berhasil membangun aplikasi Java pertama Anda menggunakan SDK for Java 2.x.

Pembersihan

Untuk membersihkan sumber daya yang Anda buat selama tutorial ini, hapus folder proyekgetstarted.

Meninjau dokumentasi AWS SDK for Java 2.x

Panduan AWS SDK for Java 2.x Pengembang mencakup semua aspek SDK di semua Layanan AWS aspek. Kami menyarankan Anda meninjau topik-topik berikut:

  • Migrasi dari versi 1.x ke 2.x - Termasuk penjelasan rinci tentang perbedaan antara 1.x dan 2.x. Topik ini juga berisi petunjuk tentang cara menggunakan kedua versi utama side-by-side.

  • Panduan DynamoDB untuk Java 2.x SDK - Menunjukkan cara melakukan operasi DynamoDB dasar: membuat tabel, memanipulasi item, dan mengambil item. Contoh-contoh ini menggunakan antarmuka tingkat rendah. Java memiliki beberapa antarmuka, seperti yang dijelaskan di bagian berikut: Antarmuka yang didukung

Tip

Setelah Anda meninjau topik ini, tandai Referensi AWS SDK for Java 2.x API. Ini mencakup semua Layanan AWS, dan kami menyarankan Anda menggunakannya sebagai referensi API utama Anda.

Antarmuka yang didukung

AWS SDK for Java 2.x Mendukung antarmuka berikut, tergantung pada tingkat abstraksi yang Anda inginkan.

Antarmuka tingkat rendah

Antarmuka tingkat rendah menyediakan one-to-one pemetaan ke API layanan yang mendasarinya. Setiap DynamoDB API tersedia melalui antarmuka ini. Ini berarti bahwa antarmuka tingkat rendah dapat menyediakan fungsionalitas yang lengkap, tetapi seringkali lebih bertele-tele dan kompleks untuk digunakan. Misalnya, Anda harus menggunakan .s() fungsi untuk menahan string dan .n() fungsi untuk menahan angka. Contoh berikut PutItemmenyisipkan item menggunakan antarmuka tingkat rendah.

import org.slf4j.*;
import software.amazon.awssdk.http.crt.AwsCrtHttpClient;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.*;

import java.util.Map;

public class PutItem {

    // Create a DynamoDB client with the default settings connected to the DynamoDB
    // endpoint in the default region based on the default credentials provider chain.
    private static final DynamoDbClient DYNAMODB_CLIENT = DynamoDbClient.create();
    private static final Logger LOGGER = LoggerFactory.getLogger(PutItem.class);

    private void putItem() {
        PutItemResponse response = DYNAMODB_CLIENT.putItem(PutItemRequest.builder()
                .item(Map.of(
                        "pk", AttributeValue.builder().s("123").build(),
                        "sk", AttributeValue.builder().s("cart#123").build(),
                        "item_data", AttributeValue.builder().s("YourItemData").build(),
                        "inventory", AttributeValue.builder().n("500").build()
                        // ... more attributes ...
                ))
                .returnConsumedCapacity(ReturnConsumedCapacity.TOTAL)
                .tableName("YourTableName")
                .build());
        LOGGER.info("PutItem call consumed [" + response.consumedCapacity().capacityUnits() + "] Write Capacity Unites (WCU)");
    }
}

Antarmuka tingkat tinggi

Antarmuka tingkat tinggi di dalam disebut DynamoDB Enhanced Client. AWS SDK for Java 2.x Antarmuka ini memberikan pengalaman penulisan kode yang lebih idiomatis.

Klien yang disempurnakan menawarkan cara untuk memetakan antara kelas data sisi klien dan tabel DynamoDB yang dirancang untuk menyimpan data tersebut. Anda menentukan hubungan antara tabel dan kelas model yang sesuai dalam kode Anda. Kemudian, Anda dapat mengandalkan SDK untuk mengelola manipulasi tipe data. Untuk informasi selengkapnya tentang klien yang disempurnakan, lihat DynamoDB API klien yang disempurnakan di AWS SDK for Java 2.x Panduan Pengembang.

Contoh berikut PutItemmenggunakan antarmuka tingkat tinggi. Dalam contoh ini, yang DynamoDbBean bernama YourItem menciptakan a TableSchema yang memungkinkan penggunaan langsungnya sebagai input untuk putItem() panggilan.

import org.slf4j.*;
import software.amazon.awssdk.enhanced.dynamodb.*;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.*;
import software.amazon.awssdk.enhanced.dynamodb.model.*;
import software.amazon.awssdk.services.dynamodb.model.ReturnConsumedCapacity;

public class DynamoDbEnhancedClientPutItem {
    private static final DynamoDbEnhancedClient ENHANCED_DYNAMODB_CLIENT = DynamoDbEnhancedClient.builder().build();
    private static final DynamoDbTable<YourItem> DYNAMODB_TABLE = ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.fromBean(YourItem.class));
    private static final Logger LOGGER = LoggerFactory.getLogger(PutItem.class);

    private void putItem() {
        PutItemEnhancedResponse<YourItem> response = DYNAMODB_TABLE.putItemWithResponse(PutItemEnhancedRequest.builder(YourItem.class)
                .item(new YourItem("123", "cart#123", "YourItemData", 500))
                .returnConsumedCapacity(ReturnConsumedCapacity.TOTAL)
                .build());
        LOGGER.info("PutItem call consumed [" + response.consumedCapacity().capacityUnits() + "] Write Capacity Unites (WCU)");
    }

    @DynamoDbBean
    public static class YourItem {

        public YourItem() {}

        public YourItem(String pk, String sk, String itemData, int inventory) {
            this.pk = pk;
            this.sk = sk;
            this.itemData = itemData;
            this.inventory = inventory;
        }

        private String pk;
        private String sk;
        private String itemData;

        private int inventory;

        @DynamoDbPartitionKey
        public void setPk(String pk) {
            this.pk = pk;
        }

        public String getPk() {
            return pk;
        }

        @DynamoDbSortKey
        public void setSk(String sk) {
            this.sk = sk;
        }

        public String getSk() {
            return sk;
        }

        public void setItemData(String itemData) {
            this.itemData = itemData;
        }

        public String getItemData() {
            return itemData;
        }

        public void setInventory(int inventory) {
            this.inventory = inventory;
        }

        public int getInventory() {
            return inventory;
        }
    }
}

AWS SDK for Java 1.x memiliki antarmuka tingkat tinggi sendiri, yang sering disebut oleh kelas utamanya. DynamoDBMapper AWS SDK for Java 2.x Ini diterbitkan dalam paket terpisah (dan artefak Maven) bernama. software.amazon.awssdk.enhanced.dynamodb Java 2.x SDK sering disebut oleh kelas utamanya. DynamoDbEnhancedClient

Antarmuka tingkat tinggi menggunakan kelas data yang tidak dapat diubah

Fitur pemetaan API klien yang disempurnakan DynamoDB juga berfungsi dengan kelas data yang tidak dapat diubah. Kelas yang tidak dapat diubah hanya memiliki getter dan memerlukan kelas pembangun yang digunakan SDK untuk membuat instance kelas. Kekekalan di Java adalah gaya yang umum digunakan yang dapat digunakan pengembang untuk membuat kelas yang tidak memiliki efek samping. Kelas-kelas ini lebih dapat diprediksi dalam perilaku mereka dalam aplikasi multi-threaded yang kompleks. Alih-alih menggunakan @DynamoDbBean anotasi seperti yang ditunjukkan dalamHigh-level interface example, kelas yang tidak dapat diubah menggunakan @DynamoDbImmutable anotasi, yang mengambil kelas pembangun sebagai inputnya.

Contoh berikut mengambil kelas builder DynamoDbEnhancedClientImmutablePutItem sebagai masukan untuk membuat skema tabel. Contoh kemudian memberikan skema sebagai input untuk panggilan PutItemAPI.

import org.slf4j.*;
import software.amazon.awssdk.enhanced.dynamodb.*;
import software.amazon.awssdk.enhanced.dynamodb.model.*;
import software.amazon.awssdk.services.dynamodb.model.ReturnConsumedCapacity;

public class DynamoDbEnhancedClientImmutablePutItem {
    private static final DynamoDbEnhancedClient ENHANCED_DYNAMODB_CLIENT = DynamoDbEnhancedClient.builder().build();
    private static final DynamoDbTable<YourImmutableItem> DYNAMODB_TABLE = ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.fromImmutableClass(YourImmutableItem.class));
    private static final Logger LOGGER = LoggerFactory.getLogger(DynamoDbEnhancedClientImmutablePutItem.class);

    private void putItem() {
        PutItemEnhancedResponse<YourImmutableItem> response = DYNAMODB_TABLE.putItemWithResponse(PutItemEnhancedRequest.builder(YourImmutableItem.class)
                .item(YourImmutableItem.builder()
                                        .pk("123")
                                        .sk("cart#123")
                                        .itemData("YourItemData")
                                        .inventory(500)
                                        .build())
                .returnConsumedCapacity(ReturnConsumedCapacity.TOTAL)
                .build());
        LOGGER.info("PutItem call consumed [" + response.consumedCapacity().capacityUnits() + "] Write Capacity Unites (WCU)");
    }
}

Contoh berikut menunjukkan kelas data yang tidak dapat diubah.

@DynamoDbImmutable(builder = YourImmutableItem.YourImmutableItemBuilder.class)
class YourImmutableItem {
    private final String pk;
    private final String sk;
    private final String itemData;
    private final int inventory;
    public YourImmutableItem(YourImmutableItemBuilder builder) {
        this.pk = builder.pk;
        this.sk = builder.sk;
        this.itemData = builder.itemData;
        this.inventory = builder.inventory;
    }

    public static YourImmutableItemBuilder builder() { return new YourImmutableItemBuilder(); }

    @DynamoDbPartitionKey
    public String getPk() {
        return pk;
    }

    @DynamoDbSortKey
    public String getSk() {
        return sk;
    }

    public String getItemData() {
        return itemData;
    }

    public int getInventory() {
        return inventory;
    }

    static final class YourImmutableItemBuilder {
        private String pk;
        private String sk;
        private String itemData;
        private int inventory;

        private YourImmutableItemBuilder() {}

        public YourImmutableItemBuilder pk(String pk) { this.pk = pk; return this; }
        public YourImmutableItemBuilder sk(String sk) { this.sk = sk; return this; }
        public YourImmutableItemBuilder itemData(String itemData) { this.itemData = itemData; return this; }
        public YourImmutableItemBuilder inventory(int inventory) { this.inventory = inventory; return this; }

        public YourImmutableItem build() { return new YourImmutableItem(this); }
    }
}

Antarmuka tingkat tinggi menggunakan kelas data yang tidak dapat diubah dan pustaka generasi boilerplate pihak ketiga

Kelas data yang tidak dapat diubah (ditunjukkan pada contoh sebelumnya) memerlukan beberapa kode boilerplate. Misalnya, logika getter dan setter pada kelas data, selain kelas. Builder Pustaka pihak ketiga, seperti Project Lombok, dapat membantu Anda menghasilkan jenis kode boilerplate tersebut. Mengurangi sebagian besar kode boilerplate membantu Anda membatasi jumlah kode yang diperlukan untuk bekerja dengan kelas data yang tidak dapat diubah dan SDK. AWS Ini selanjutnya menghasilkan peningkatan produktivitas dan keterbacaan kode Anda. Untuk informasi selengkapnya, lihat Menggunakan pustaka pihak ketiga, seperti Lombok di Panduan AWS SDK for Java 2.x Pengembang.

Contoh berikut menunjukkan bagaimana Project Lombok menyederhanakan kode yang diperlukan untuk menggunakan DynamoDB ditingkatkan client API.

import org.slf4j.*;
import software.amazon.awssdk.enhanced.dynamodb.*;
import software.amazon.awssdk.enhanced.dynamodb.model.*;
import software.amazon.awssdk.services.dynamodb.model.ReturnConsumedCapacity;

public class DynamoDbEnhancedClientImmutableLombokPutItem {

    private static final DynamoDbEnhancedClient ENHANCED_DYNAMODB_CLIENT = DynamoDbEnhancedClient.builder().build();
    private static final DynamoDbTable<YourImmutableLombokItem> DYNAMODB_TABLE = ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.fromImmutableClass(YourImmutableLombokItem.class));
    private static final Logger LOGGER = LoggerFactory.getLogger(DynamoDbEnhancedClientImmutableLombokPutItem.class);

    private void putItem() {
        PutItemEnhancedResponse<YourImmutableLombokItem> response = DYNAMODB_TABLE.putItemWithResponse(PutItemEnhancedRequest.builder(YourImmutableLombokItem.class)
                .item(YourImmutableLombokItem.builder()
                        .pk("123")
                        .sk("cart#123")
                        .itemData("YourItemData")
                        .inventory(500)
                        .build())
                .returnConsumedCapacity(ReturnConsumedCapacity.TOTAL)
                .build());
        LOGGER.info("PutItem call consumed [" + response.consumedCapacity().capacityUnits() + "] Write Capacity Unites (WCU)");
    }
}

Contoh berikut menunjukkan objek data yang tidak berubah dari kelas data yang tidak dapat diubah.

import lombok.*;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.*;

@Builder
@DynamoDbImmutable(builder = YourImmutableLombokItem.YourImmutableLombokItemBuilder.class)
@Value
public class YourImmutableLombokItem {

    @Getter(onMethod_=@DynamoDbPartitionKey)
    String pk;
    @Getter(onMethod_=@DynamoDbSortKey)
    String sk;
    String itemData;
    int inventory;
}

YourImmutableLombokItemKelas menggunakan anotasi berikut yang Project Lombok dan AWS SDK menyediakan:

  • @Builder — Menghasilkan API pembangun kompleks untuk kelas data yang disediakan Project Lombok.

  • @ DynamoDb Immutable — Mengidentifikasi DynamoDbImmutable kelas sebagai anotasi entitas yang dapat dipetakan DynamoDB yang disediakan SDK. AWS

  • @Value — Varian yang tidak dapat diubah dari. @Data Secara default, semua bidang dibuat pribadi dan final, dan setter tidak dibuat. Proyek Lombok memberikan anotasi ini.

Antarmuka dokumen

Antarmuka AWS SDK for Java 2.x Dokumen menghindari kebutuhan untuk menentukan deskriptor tipe data. Jenis data yang tersirat oleh semantik data itu sendiri. Antarmuka Dokumen ini mirip dengan antarmuka AWS SDK for Java 1.x, Dokumen, tetapi dengan antarmuka yang didesain ulang.

Berikut ini Document interface example menunjukkan PutItem panggilan yang dinyatakan menggunakan antarmuka Dokumen. Contoh ini juga menggunakan EnhancedDocument. Untuk menjalankan perintah terhadap tabel DynamoDB menggunakan API dokumen yang disempurnakan, Anda harus terlebih dahulu mengaitkan tabel dengan skema tabel dokumen Anda untuk membuat objek sumber daya. DynamoDBTable Pembuat skema tabel Dokumen memerlukan kunci indeks utama dan penyedia konverter atribut.

Anda dapat menggunakan AttributeConverterProvider.defaultProvider() untuk mengonversi atribut dokumen dari tipe default. Anda dapat mengubah keseluruhan perilaku default dengan AttributeConverterProvider implementasi kustom. Anda juga dapat mengubah konverter untuk satu atribut. Panduan Referensi AWS SDK dan Alat memberikan detail dan contoh selengkapnya tentang cara menggunakan konverter khusus. Penggunaan utamanya adalah untuk atribut kelas domain Anda yang tidak memiliki konverter default yang tersedia. Menggunakan konverter khusus, Anda dapat memberikan SDK dengan informasi yang diperlukan untuk menulis atau membaca ke DynamoDB.

import org.slf4j.*;
import software.amazon.awssdk.enhanced.dynamodb.*;
import software.amazon.awssdk.enhanced.dynamodb.document.EnhancedDocument;
import software.amazon.awssdk.enhanced.dynamodb.model.*;
import software.amazon.awssdk.services.dynamodb.model.ReturnConsumedCapacity;

public class DynamoDbEnhancedDocumentClientPutItem {
    private static final DynamoDbEnhancedClient ENHANCED_DYNAMODB_CLIENT = DynamoDbEnhancedClient.builder().build();
    private static final DynamoDbTable<EnhancedDocument> DYNAMODB_TABLE =
            ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.documentSchemaBuilder()
                            .addIndexPartitionKey(TableMetadata.primaryIndexName(),"pk", AttributeValueType.S)
                            .addIndexSortKey(TableMetadata.primaryIndexName(), "sk", AttributeValueType.S)
                            .attributeConverterProviders(AttributeConverterProvider.defaultProvider())
                            .build());

    private static final Logger LOGGER = LoggerFactory.getLogger(DynamoDbEnhancedDocumentClientPutItem.class);

    private void putItem() {
        PutItemEnhancedResponse<EnhancedDocument> response = DYNAMODB_TABLE.putItemWithResponse(
                        PutItemEnhancedRequest.builder(EnhancedDocument.class)
                                .item(
                                    EnhancedDocument.builder()
                                            .attributeConverterProviders(AttributeConverterProvider.defaultProvider())
                                            .putString("pk", "123")
                                            .putString("sk", "cart#123")
                                            .putString("item_data", "YourItemData")
                                            .putNumber("inventory", 500)
                                            .build())
                                .returnConsumedCapacity(ReturnConsumedCapacity.TOTAL)
                                .build());
        LOGGER.info("PutItem call consumed [" + response.consumedCapacity().capacityUnits() + "] Write Capacity Unites (WCU)");
    }

}

Untuk mengonversi dokumen JSON ke dan dari tipe data Amazon DynamoDB asli, Anda dapat menggunakan metode utilitas berikut:

Membandingkan antarmuka dengan contoh Query

Bagian ini menunjukkan Querypanggilan yang sama yang diekspresikan menggunakan berbagai antarmuka. Untuk menyempurnakan hasil kueri ini, perhatikan hal berikut:

  • DynamoDB menargetkan satu nilai kunci partisi tertentu, jadi Anda harus menentukan kunci partisi sepenuhnya.

  • Untuk memiliki item keranjang target kueri saja, kunci pengurutan memiliki ekspresi kondisi kunci yang menggunakanbegins_with.

  • Kami gunakan limit() untuk membatasi kueri hingga maksimum 100 item yang dikembalikan.

  • Kami mengatur scanIndexForward ke false. Hasilnya dikembalikan dalam urutan UTF-8 byte, yang biasanya berarti item keranjang dengan jumlah terendah dikembalikan terlebih dahulu. Dengan menyetel scanIndexForward ke false, kami membalikkan pesanan dan item keranjang dengan angka tertinggi dikembalikan terlebih dahulu.

  • Kami menerapkan filter untuk menghapus hasil apa pun yang tidak sesuai dengan kriteria. Data yang difilter menghabiskan kapasitas baca apakah item tersebut cocok dengan filter.

contoh Querymenggunakan antarmuka tingkat rendah

Contoh berikut query tabel bernama YourTableName menggunakan. keyConditionExpression Ini membatasi kueri ke nilai kunci partisi tertentu dan mengurutkan nilai kunci yang dimulai dengan nilai awalan tertentu. Kondisi utama ini membatasi jumlah data yang dibaca dari DynamoDB. Akhirnya, kueri menerapkan filter pada data yang diambil dari DynamoDB menggunakan file. filterExpression

import org.slf4j.*;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.*;

import java.util.Map;

public class Query {

    // Create a DynamoDB client with the default settings connected to the DynamoDB 
    // endpoint in the default region based on the default credentials provider chain.
    private static final DynamoDbClient DYNAMODB_CLIENT = DynamoDbClient.builder().build();
    private static final Logger LOGGER = LoggerFactory.getLogger(Query.class);

    private static void query() {
        QueryResponse response = DYNAMODB_CLIENT.query(QueryRequest.builder()
                .expressionAttributeNames(Map.of("#name", "name"))
                .expressionAttributeValues(Map.of(
                    ":pk_val", AttributeValue.fromS("id#1"),
                    ":sk_val", AttributeValue.fromS("cart#"),
                    ":name_val", AttributeValue.fromS("SomeName")))
                .filterExpression("#name = :name_val")
                .keyConditionExpression("pk = :pk_val AND begins_with(sk, :sk_val)")
                .limit(100)
                .scanIndexForward(false)
                .tableName("YourTableName")
                .build());

        LOGGER.info("nr of items: " + response.count());
        LOGGER.info("First item pk: " + response.items().get(0).get("pk"));
        LOGGER.info("First item sk: " + response.items().get(0).get("sk"));
    }
}
contoh Querymenggunakan antarmuka Dokumen

Contoh berikut query tabel bernama YourTableName menggunakan antarmuka Dokumen.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.enhanced.dynamodb.*;
import software.amazon.awssdk.enhanced.dynamodb.document.EnhancedDocument;
import software.amazon.awssdk.enhanced.dynamodb.model.*;

import java.util.Map;

public class DynamoDbEnhancedDocumentClientQuery {

    // Create a DynamoDB client with the default settings connected to the DynamoDB 
    // endpoint in the default region based on the default credentials provider chain.
    private static final DynamoDbEnhancedClient ENHANCED_DYNAMODB_CLIENT = DynamoDbEnhancedClient.builder().build();
    private static final DynamoDbTable<EnhancedDocument> DYNAMODB_TABLE =
            ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.documentSchemaBuilder()
                    .addIndexPartitionKey(TableMetadata.primaryIndexName(),"pk", AttributeValueType.S)
                    .addIndexSortKey(TableMetadata.primaryIndexName(), "sk", AttributeValueType.S)
                    .attributeConverterProviders(AttributeConverterProvider.defaultProvider())
                    .build());
    private static final Logger LOGGER = LoggerFactory.getLogger(DynamoDbEnhancedDocumentClientQuery.class);

    private void query() {
        PageIterable<EnhancedDocument> response = DYNAMODB_TABLE.query(QueryEnhancedRequest.builder()
                .filterExpression(Expression.builder()
                        .expression("#name = :name_val")
                        .expressionNames(Map.of("#name", "name"))
                        .expressionValues(Map.of(":name_val", AttributeValue.fromS("SomeName")))
                        .build())
                .limit(100)
                .queryConditional(QueryConditional.sortBeginsWith(Key.builder()
                        .partitionValue("id#1")
                        .sortValue("cart#")
                        .build()))
                .scanIndexForward(false)
                .build());

        LOGGER.info("nr of items: " + response.items().stream().count());
        LOGGER.info("First item pk: " + response.items().iterator().next().getString("pk"));
        LOGGER.info("First item sk: " + response.items().iterator().next().getString("sk"));

    }
}
contoh Querymenggunakan antarmuka tingkat tinggi

Contoh berikut menanyakan tabel bernama YourTableName menggunakan DynamoDB API klien yang disempurnakan.

import org.slf4j.*;
import software.amazon.awssdk.enhanced.dynamodb.*;
import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.*;
import software.amazon.awssdk.enhanced.dynamodb.model.*;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;

import java.util.Map;

public class DynamoDbEnhancedClientQuery {

    private static final DynamoDbEnhancedClient ENHANCED_DYNAMODB_CLIENT = DynamoDbEnhancedClient.builder().build();
    private static final DynamoDbTable<YourItem> DYNAMODB_TABLE = ENHANCED_DYNAMODB_CLIENT.table("YourTableName", TableSchema.fromBean(DynamoDbEnhancedClientQuery.YourItem.class));
    private static final Logger LOGGER = LoggerFactory.getLogger(DynamoDbEnhancedClientQuery.class);

    private void query() {
        PageIterable<YourItem> response = DYNAMODB_TABLE.query(QueryEnhancedRequest.builder()
                .filterExpression(Expression.builder()
                        .expression("#name = :name_val")
                        .expressionNames(Map.of("#name", "name"))
                        .expressionValues(Map.of(":name_val", AttributeValue.fromS("SomeName")))
                        .build())
                .limit(100)
                .queryConditional(QueryConditional.sortBeginsWith(Key.builder()
                        .partitionValue("id#1")
                        .sortValue("cart#")
                        .build()))
                .scanIndexForward(false)
                .build());

        LOGGER.info("nr of items: " + response.items().stream().count());
        LOGGER.info("First item pk: " + response.items().iterator().next().getPk());
        LOGGER.info("First item sk: " + response.items().iterator().next().getSk());
    }

    @DynamoDbBean
    public static class YourItem {

        public YourItem() {}

        public YourItem(String pk, String sk, String name) {
            this.pk = pk;
            this.sk = sk;
            this.name = name;
        }

        private String pk;
        private String sk;
        private String name;

        @DynamoDbPartitionKey
        public void setPk(String pk) {
            this.pk = pk;
        }

        public String getPk() {
            return pk;
        }

        @DynamoDbSortKey
        public void setSk(String sk) {
            this.sk = sk;
        }

        public String getSk() {
            return sk;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    }
}
Antarmuka tingkat tinggi menggunakan kelas data yang tidak dapat diubah

Saat Anda melakukan a Query dengan kelas data abadi tingkat tinggi, kodenya sama dengan contoh antarmuka tingkat tinggi kecuali untuk konstruksi kelas entitas atau. YourItem YourImmutableItem Untuk informasi lebih lanjut, lihat PutItemcontoh.

Antarmuka tingkat tinggi menggunakan kelas data yang tidak dapat diubah dan pustaka generasi boilerplate pihak ketiga

Saat Anda melakukan a Query dengan kelas data abadi tingkat tinggi, kodenya sama dengan contoh antarmuka tingkat tinggi kecuali untuk konstruksi kelas entitas atau. YourItem YourImmutableLombokItem Untuk informasi lebih lanjut, lihat PutItemcontoh.

Contoh kode tambahan

Untuk contoh tambahan tentang cara menggunakan DynamoDB dengan SDK for Java 2.x, lihat repositori contoh kode berikut:

Pemrograman sinkron dan asinkron

AWS SDK for Java 2.x Ini menyediakan klien sinkron dan asinkron untuk, Layanan AWS seperti DynamoDB.

DynamoDbEnhancedClientKelas DynamoDbClient dan menyediakan metode sinkron yang memblokir eksekusi thread Anda hingga klien menerima respons dari layanan. Klien ini adalah cara paling mudah untuk berinteraksi dengan DynamoDB jika Anda tidak memerlukan operasi asinkron.

DynamoDbEnhancedAsyncClientKelas DynamoDbAsyncClient and menyediakan metode asinkron yang segera kembali, dan memberikan kontrol kembali ke utas panggilan tanpa menunggu respons. Klien non-pemblokiran memiliki keuntungan yang digunakannya untuk konkurensi tinggi di beberapa utas, yang menyediakan penanganan permintaan I/O yang efisien dengan sumber daya komputasi minimal. Ini meningkatkan throughput dan daya tanggap.

AWS SDK for Java 2.x Menggunakan dukungan asli untuk non-blocking I/O. AWS SDK for Java 1.x harus mensimulasikan non-blocking I/O.

Metode sinkron kembali sebelum respons tersedia, jadi Anda memerlukan cara untuk mendapatkan respons saat sudah siap. Metode asinkron dalam AWS SDK for Java mengembalikan CompletableFutureobjek yang berisi hasil operasi asinkron di masa depan. Ketika Anda memanggil get() atau join() pada CompletableFuture objek-objek ini, kode Anda memblokir sampai hasilnya tersedia. Jika Anda memanggil ini pada saat yang sama saat Anda membuat permintaan, maka perilakunya mirip dengan panggilan sinkron biasa.

Untuk informasi selengkapnya tentang pemrograman asinkron, lihat Menggunakan pemrograman asinkron di Panduan Pengembang.AWS SDK for Java 2.x

Klien HTTP

Untuk mendukung setiap klien, ada klien HTTP yang menangani komunikasi dengan klien Layanan AWS. Anda dapat mencolokkan klien HTTP alternatif, memilih salah satu yang memiliki karakteristik yang paling sesuai dengan aplikasi Anda. Beberapa lebih ringan; beberapa memiliki lebih banyak opsi konfigurasi.

Beberapa klien HTTP hanya mendukung penggunaan sinkron, sementara yang lain hanya mendukung penggunaan asinkron. Untuk diagram alur yang dapat membantu Anda memilih klien HTTP optimal untuk beban kerja Anda, lihat rekomendasi klien HTTP di Panduan AWS SDK for Java 2.x Pengembang.

Daftar berikut menyajikan beberapa kemungkinan klien HTTP:

Klien HTTP berbasis Apache

ApacheHttpClientKelas mendukung klien layanan sinkron. Ini adalah klien HTTP default untuk penggunaan sinkron. Untuk informasi tentang mengonfigurasi ApacheHttpClient kelas, lihat Mengkonfigurasi klien HTTP berbasis Apache di Panduan Pengembang.AWS SDK for Java 2.x

URLConnectionberbasis HTTP klien

UrlConnectionHttpClientKelas adalah pilihan lain untuk klien sinkron. Ini memuat lebih cepat daripada klien HTTP berbasis Apache, tetapi memiliki lebih sedikit fitur. Untuk informasi tentang mengonfigurasi UrlConnectionHttpClient kelas, lihat Mengkonfigurasi klien HTTP berbasis URLConnection di Panduan Pengembang.AWS SDK for Java 2.x

Klien HTTP berbasis Netty

NettyNioAsyncHttpClientKelas mendukung klien async. Ini adalah pilihan default untuk penggunaan async. Untuk informasi tentang mengonfigurasi NettyNioAsyncHttpClient kelas, lihat Mengkonfigurasi klien HTTP berbasis Netty di Panduan Pengembang.AWS SDK for Java 2.x

AWS Klien HTTP berbasis CRT

Yang lebih baru AwsCrtHttpClient dan AwsCrtAsyncHttpClient kelas dari pustaka AWS Common Runtime (CRT) adalah lebih banyak opsi yang mendukung klien sinkron dan asinkron. Dibandingkan dengan klien HTTP lainnya, AWS CRT menawarkan:

  • Waktu startup SDK lebih cepat

  • Jejak memori yang lebih kecil

  • Mengurangi waktu latensi

  • Manajemen kesehatan koneksi

  • Penyeimbangan beban DNS

Untuk informasi tentang mengonfigurasi AwsCrtHttpClient dan AwsCrtAsyncHttpClient kelas, lihat Mengkonfigurasi klien HTTP AWS berbasis CRT di Panduan Pengembang AWS SDK for Java 2.x .

Klien HTTP AWS berbasis CRT bukan default karena itu akan merusak kompatibilitas mundur untuk aplikasi yang ada. Namun, untuk DynamoDB kami menyarankan Anda menggunakan klien HTTP berbasis CRT untuk penggunaan AWS sinkronisasi dan asinkron.

Untuk pengenalan klien HTTP AWS berbasis CRT, lihat Mengumumkan ketersediaan AWS CRT HTTP Client di Blog Alat Pengembang AWS SDK for Java 2.x.AWS

Mengkonfigurasi klien HTTP

Saat mengonfigurasi klien, Anda dapat memberikan berbagai opsi konfigurasi, termasuk:

  • Menyetel batas waktu untuk berbagai aspek panggilan API.

  • Mengaktifkan TCP Keep-Alive.

  • Mengontrol kebijakan coba lagi saat mengalami kesalahan.

  • Menentukan atribut eksekusi yang dapat dimodifikasi oleh instance pencegat Eksekusi. Pencegat eksekusi dapat menulis kode yang mencegat eksekusi permintaan dan tanggapan API Anda. Ini memungkinkan Anda untuk melakukan tugas-tugas seperti menerbitkan metrik dan memodifikasi permintaan dalam penerbangan.

  • Menambahkan atau memanipulasi header HTTP.

  • Mengaktifkan pelacakan metrik kinerja sisi klien. Menggunakan fitur ini membantu Anda mengumpulkan metrik tentang klien layanan di aplikasi Anda dan menganalisis output di Amazon CloudWatch.

  • Menentukan layanan pelaksana alternatif yang akan digunakan untuk menjadwalkan tugas, seperti percobaan ulang async dan tugas batas waktu.

Anda mengontrol konfigurasi dengan menyediakan ClientOverrideConfigurationobjek ke Builder kelas klien layanan. Anda akan melihat ini di beberapa contoh kode di bagian berikut.

ClientOverrideConfigurationIni menyediakan pilihan konfigurasi standar. Klien HTTP pluggable yang berbeda memiliki kemungkinan konfigurasi khusus implementasi juga.

Konfigurasi waktu habis

Anda dapat menyesuaikan konfigurasi klien untuk mengontrol berbagai batas waktu yang terkait dengan panggilan layanan. DynamoDB memberikan latensi yang lebih rendah dibandingkan dengan yang lain. Layanan AWS Oleh karena itu, Anda mungkin ingin menyesuaikan properti ini untuk menurunkan nilai batas waktu sehingga Anda dapat gagal dengan cepat jika ada masalah jaringan.

Anda dapat menyesuaikan perilaku terkait latensi menggunakan ClientOverrideConfiguration pada klien DynamoDB atau dengan mengubah opsi konfigurasi terperinci pada implementasi klien HTTP yang mendasarinya.

Anda dapat mengonfigurasi properti berdampak berikut menggunakan: ClientOverrideConfiguration

  • apiCallAttemptTimeout— Jumlah waktu untuk menunggu satu upaya untuk menyelesaikan permintaan HTTP sebelum menyerah dan waktu habis.

  • apiCallTimeout— Jumlah waktu yang dimiliki klien untuk sepenuhnya menjalankan panggilan API. Ini termasuk eksekusi penangan permintaan yang terdiri dari semua permintaan HTTP, termasuk percobaan ulang.

AWS SDK for Java 2.x Ini memberikan nilai default untuk beberapa opsi batas waktu, seperti batas waktu koneksi dan batas waktu soket. SDK tidak memberikan nilai default untuk batas waktu panggilan API atau batas waktu percobaan panggilan API individual. Jika batas waktu ini tidak disetel dalamClientOverrideConfiguration, maka SDK menggunakan nilai batas waktu soket sebagai gantinya untuk batas waktu panggilan API secara keseluruhan. Batas waktu soket memiliki nilai default 30 detik.

RetryMode

Konfigurasi lain yang terkait dengan konfigurasi batas waktu yang harus Anda pertimbangkan adalah objek RetryMode konfigurasi. Objek konfigurasi ini berisi kumpulan perilaku coba lagi.

SDK for Java 2.x mendukung mode coba lagi berikut:

  • legacy— Mode coba lagi default jika Anda tidak mengubahnya secara eksplisit. Mode coba lagi ini khusus untuk Java SDK. Ini ditandai dengan hingga tiga percobaan ulang, atau lebih untuk layanan seperti DynamoDB, yang memiliki hingga delapan percobaan ulang.

  • standard— Dinamakan “standar” karena lebih konsisten dengan AWS SDK lain. Mode ini menunggu jumlah waktu acak mulai dari 0ms hingga 1.000 ms untuk percobaan ulang pertama. Jika percobaan lagi diperlukan, maka mode ini mengambil waktu acak lain dari 0ms menjadi 1.000 ms dan mengalikannya dengan dua. Jika percobaan ulang tambahan diperlukan, maka ia melakukan pengambilan acak yang sama dikalikan empat, dan seterusnya. Setiap penantian dibatasi pada 20 detik. Mode ini melakukan percobaan ulang pada kondisi kegagalan yang lebih terdeteksi daripada legacy mode. Untuk DynamoDB, ia melakukan hingga tiga upaya maksimal total kecuali Anda mengganti dengan. numRetries

  • adaptive— Dibangun pada standard mode dan secara dinamis membatasi tingkat AWS permintaan untuk memaksimalkan tingkat keberhasilan. Ini dapat terjadi dengan mengorbankan latensi permintaan. Kami tidak merekomendasikan mode coba lagi adaptif ketika latensi yang dapat diprediksi penting.

Anda dapat menemukan definisi yang diperluas dari mode coba lagi ini dalam topik perilaku Coba lagi di Panduan Referensi AWS SDK dan Alat.

Coba lagi kebijakan

Semua RetryMode konfigurasi memiliki RetryPolicy, yang dibangun berdasarkan satu atau lebih RetryConditionkonfigurasi. TokenBucketRetryConditionIni sangat penting untuk perilaku coba lagi implementasi klien DynamoDB SDK. Kondisi ini membatasi jumlah percobaan ulang yang dibuat SDK menggunakan algoritma token bucket. Bergantung pada mode coba lagi yang dipilih, pengecualian pembatasan mungkin atau mungkin tidak mengurangi token dari. TokenBucket

Ketika klien menemukan kesalahan yang dapat dicoba ulang, seperti pengecualian pembatasan atau kesalahan server sementara, SDK secara otomatis mencoba ulang permintaan tersebut. Anda dapat mengontrol berapa kali dan seberapa cepat percobaan ulang ini terjadi.

Saat mengkonfigurasi klien, Anda dapat memberikan RetryPolicy yang mendukung parameter berikut:

  • numRetriesJumlah maksimum percobaan ulang yang harus diterapkan sebelum permintaan dianggap gagal. Nilai defaultnya adalah 8 terlepas dari mode coba lagi yang Anda gunakan.

    Awas

    Pastikan Anda mengubah nilai default ini setelah mempertimbangkan.

  • backoffStrategy— BackoffStrategyUntuk diterapkan pada percobaan ulang, dengan FullJitterBackoffStrategymenjadi strategi default. Strategi ini melakukan penundaan eksponensial antara percobaan ulang tambahan berdasarkan jumlah saat ini atau percobaan ulang, penundaan dasar, dan waktu backoff maksimum. Kemudian menambahkan jitter untuk memberikan sedikit keacakan. Penundaan dasar yang digunakan dalam penundaan eksponensial adalah 25 ms terlepas dari mode coba lagi.

  • retryCondition— RetryConditionMenentukan apakah akan mencoba kembali permintaan sama sekali. Secara default, ia mencoba ulang satu set kode status HTTP tertentu dan pengecualian yang diyakini dapat dicoba ulang. Untuk sebagian besar situasi, konfigurasi default harus cukup.

Kode berikut menyediakan kebijakan coba lagi alternatif. Ini menentukan total lima percobaan ulang (enam permintaan total). Percobaan ulang pertama harus dilakukan setelah penundaan sekitar 100 ms, dengan setiap percobaan lagi tambahan menggandakan waktu itu secara eksponensial, hingga penundaan maksimum satu detik.

DynamoDbClient client = DynamoDbClient.builder()
    .overrideConfiguration(ClientOverrideConfiguration.builder()
        .retryPolicy(RetryPolicy.builder()
            .backoffStrategy(FullJitterBackoffStrategy.builder()
                .baseDelay(Duration.ofMillis(100))
                .maxBackoffTime(Duration.ofSeconds(1))
                .build())
            .numRetries(5)
            .build())
        .build())
    .build();

DefaultsMode

Properti batas waktu yang ClientOverrideConfiguration dan RetryMode tidak dikelola biasanya dikonfigurasi secara implisit dengan menentukan. DefaultsMode

AWS SDK for Java 2.x (versi 2.17.102 atau yang lebih baru) memperkenalkan dukungan untuk. DefaultsMode Fitur ini menyediakan serangkaian nilai default untuk pengaturan umum yang dapat dikonfigurasi, seperti pengaturan komunikasi HTTP, perilaku coba lagi, pengaturan titik akhir Regional layanan, dan kemungkinan konfigurasi terkait SDK apa pun. Saat Anda menggunakan fitur ini, Anda bisa mendapatkan default konfigurasi baru yang disesuaikan dengan skenario penggunaan umum.

Mode default distandarisasi di semua SDK. AWS SDK for Java 2.x mendukung mode default berikut:

  • legacy— Menyediakan pengaturan default yang bervariasi menurut AWS SDK dan yang ada sebelum DefaultsMode dibuat.

  • standard— Menyediakan pengaturan default yang tidak dioptimalkan untuk sebagian besar skenario.

  • in-region— Dibangun pada mode standar dan termasuk pengaturan yang disesuaikan untuk aplikasi yang memanggil Layanan AWS dari dalam yang sama. Wilayah AWS

  • cross-region— Dibangun pada mode standar dan termasuk pengaturan dengan batas waktu tinggi untuk aplikasi yang memanggil Layanan AWS di Wilayah yang berbeda.

  • mobile— Dibangun pada mode standar dan mencakup pengaturan dengan batas waktu tinggi yang disesuaikan untuk aplikasi seluler dengan latensi lebih tinggi.

  • auto— Dibangun pada mode standar dan termasuk fitur eksperimental. SDK mencoba menemukan lingkungan runtime untuk menentukan pengaturan yang sesuai secara otomatis. Deteksi otomatis berbasis heuristik dan tidak memberikan akurasi 100%. Jika lingkungan runtime tidak dapat ditentukan, maka mode standar digunakan. Deteksi otomatis mungkin menanyakan metadata Instance dan data pengguna, yang mungkin memperkenalkan latensi. Jika latensi startup sangat penting untuk aplikasi Anda, sebaiknya pilih yang eksplisitDefaultsMode.

Anda dapat mengonfigurasi mode default dengan cara berikut:

  • Langsung pada klien, melaluiAwsClientBuilder.Builder#defaultsMode(DefaultsMode).

  • Pada profil konfigurasi, melalui properti file defaults_mode profil.

  • Secara global, melalui properti aws.defaultsMode sistem.

  • Secara global, melalui variabel AWS_DEFAULTS_MODE lingkungan.

catatan

Untuk mode apa pun selainlegacy, nilai default yang dijual dapat berubah seiring berkembangnya praktik terbaik. Oleh karena itu, jika Anda menggunakan mode selainlegacy, maka kami mendorong Anda untuk melakukan pengujian saat memutakhirkan SDK.

Konfigurasi Smart default di AWS SDK dan Tools Reference Guide menyediakan daftar properti konfigurasi dan nilai defaultnya dalam mode default yang berbeda.

Anda memilih nilai mode default berdasarkan karakteristik aplikasi Anda dan interaksi dengan Layanan AWS aplikasi.

Nilai-nilai ini dikonfigurasi dengan berbagai pilihan Layanan AWS dalam pikiran. Untuk penerapan DynamoDB tipikal di mana tabel dan aplikasi DynamoDB Anda digunakan dalam satu Wilayah, mode default in-region paling relevan di antara mode default. standard

contoh Konfigurasi klien DynamoDB SDK disetel untuk panggilan latensi rendah

Contoh berikut menyesuaikan batas waktu ke nilai yang lebih rendah untuk panggilan DynamoDB latensi rendah yang diharapkan.

DynamoDbAsyncClient asyncClient = DynamoDbAsyncClient.builder()
    .defaultsMode(DefaultsMode.IN_REGION)
    .httpClientBuilder(AwsCrtAsyncHttpClient.builder())
    .overrideConfiguration(ClientOverrideConfiguration.builder()
        .apiCallTimeout(Duration.ofSeconds(3))
        .apiCallAttemptTimeout(Duration.ofMillis(500))
        .build())
    .build();

Implementasi klien HTTP individual dapat memberi Anda kontrol yang lebih terperinci atas batas waktu dan perilaku penggunaan koneksi. Misalnya, untuk klien AWS berbasis CRT, Anda dapat mengaktifkanConnectionHealthConfiguration, yang memungkinkan klien untuk secara aktif memantau kesehatan koneksi yang digunakan. Untuk informasi selengkapnya, lihat Konfigurasi lanjutan klien HTTP AWS berbasis CRT di Panduan AWS SDK for Java 2.x Pengembang.

Konfigurasi Keep-Alive

Mengaktifkan keep-alive dapat mengurangi latensi dengan menggunakan kembali koneksi. Ada dua jenis keep-alive: HTTP Keep-Alive dan TCP Keep-Alive.

  • HTTP Keep-Alive mencoba mempertahankan koneksi HTTPS antara klien dan server sehingga permintaan selanjutnya dapat menggunakan kembali koneksi tersebut. Ini melewatkan otentikasi HTTPS kelas berat pada permintaan selanjutnya. HTTP Keep-Alive diaktifkan secara default pada semua klien.

  • TCP Keep-Alive meminta agar sistem operasi yang mendasarinya mengirimkan paket kecil melalui koneksi soket untuk memberikan jaminan ekstra bahwa soket tetap hidup dan segera mendeteksi tetesan apa pun. Ini memastikan bahwa permintaan selanjutnya tidak akan menghabiskan waktu mencoba menggunakan soket yang terjatuh. Secara default, TCP Keep-Alive dinonaktifkan pada semua klien. Contoh kode berikut menunjukkan cara mengaktifkannya pada setiap klien HTTP. Ketika diaktifkan untuk semua klien HTTP berbasis non-CRT, mekanisme Keep-Alive yang sebenarnya bergantung pada sistem operasi. Oleh karena itu, Anda harus mengonfigurasi nilai TCP Keep-Alive tambahan, seperti batas waktu dan jumlah paket, melalui sistem operasi. Anda dapat melakukan ini menggunakan sysctl di Linux atau macOS, atau menggunakan nilai registri di Windows.

contoh untuk mengaktifkan TCP Keep-Alive pada klien HTTP berbasis Apache
DynamoDbClient client = DynamoDbClient.builder()
    .httpClientBuilder(ApacheHttpClient.builder().tcpKeepAlive(true))
    .build();
URLConnectionberbasis HTTP klien

Setiap klien sinkron yang menggunakan klien HTTP URLConnection berbasis HttpURLConnectiontidak memiliki mekanisme untuk mengaktifkan keep-alive.

contoh untuk mengaktifkan TCP Keep-Alive pada klien HTTP berbasis Netty
DynamoDbAsyncClient client = DynamoDbAsyncClient.builder()
    .httpClientBuilder(NettyNioAsyncHttpClient.builder().tcpKeepAlive(true))
    .build();
contoh untuk mengaktifkan TCP Keep-Alive pada klien HTTP berbasis CRT AWS

Dengan klien HTTP AWS berbasis CRT, Anda dapat mengaktifkan TCP keep-alive dan mengontrol durasinya.

DynamoDbClient client = DynamoDbClient.builder()
    .httpClientBuilder(AwsCrtHttpClient.builder()
    .tcpKeepAliveConfiguration(TcpKeepAliveConfiguration.builder()
        .keepAliveInterval(Duration.ofSeconds(50))
        .keepAliveTimeout(Duration.ofSeconds(5))
        .build()))
    .build();

Saat menggunakan klien DynamoDB asinkron, Anda dapat mengaktifkan TCP Keep-Alive seperti yang ditunjukkan pada kode berikut.

DynamoDbAsyncClient client = DynamoDbAsyncClient.builder()
    .httpClientBuilder(AwsCrtAsyncHttpClient.builder()
    .tcpKeepAliveConfiguration(TcpKeepAliveConfiguration.builder()
        .keepAliveInterval(Duration.ofSeconds(50))
        .keepAliveTimeout(Duration.ofSeconds(5))
        .build()))
    .build();

Penanganan kesalahan

Ketika datang ke penanganan pengecualian, AWS SDK for Java 2.x menggunakan pengecualian runtime (tidak dicentang).

Pengecualian dasar, yang mencakup semua pengecualian SDK, adalah SdkServiceException, yang meluas dari Java tidak dicentang. RuntimeException Jika Anda menangkap ini, Anda akan menangkap semua pengecualian yang dilemparkan SDK.

SdkServiceExceptionmemiliki subclass yang disebut AwsServiceException. Subkelas ini menunjukkan masalah apa pun dalam komunikasi dengan. Layanan AWS Ini memiliki subclass yang disebut DynamoDbException, yang menunjukkan masalah dalam komunikasi dengan DynamoDB. Jika Anda menangkap ini, Anda akan menangkap semua pengecualian yang terkait dengan DynamoDB, tetapi tidak ada pengecualian SDK lainnya.

Ada jenis pengecualian yang lebih spesifik di bawahDynamoDbException. Beberapa jenis pengecualian ini berlaku untuk operasi bidang kontrol seperti. TableAlreadyExistsException Lainnya berlaku untuk operasi data-plane. Berikut ini adalah contoh pengecualian bidang data umum:

  • ConditionalCheckFailedException— Anda menentukan kondisi dalam permintaan yang dievaluasi menjadi false. Misalnya, Anda mungkin telah mencoba melakukan pembaruan bersyarat pada suatu item, tetapi nilai atribut sebenarnya tidak cocok dengan nilai yang diharapkan dalam kondisi yang dihadapi. Permintaan yang gagal dengan cara ini tidak dicoba lagi.

Situasi lain tidak memiliki pengecualian khusus yang ditentukan. Misalnya, ketika permintaan Anda dibatasi, spesifik ProvisionedThroughputExceededException mungkin dilemparkan, sementara dalam kasus lain permintaan yang lebih umum DynamoDbException dilemparkan. Dalam kedua kasus tersebut, Anda dapat menentukan apakah pelambatan menyebabkan pengecualian dengan memeriksa apakah isThrottlingException() pengembalian. true

Tergantung pada kebutuhan aplikasi Anda, Anda dapat menangkap semua AwsServiceException atau DynamoDbException instance. Namun, Anda sering membutuhkan perilaku yang berbeda dalam situasi yang berbeda. Logika untuk menangani kegagalan pemeriksaan kondisi berbeda dari itu untuk menangani pelambatan. Tentukan jalur luar biasa mana yang ingin Anda tangani dan pastikan untuk menguji jalur alternatif. Ini membantu Anda memastikan bahwa Anda dapat menangani semua skenario yang relevan.

Untuk daftar kesalahan umum yang mungkin Anda temui, lihatPenanganan kesalahan dengan DynamoDB. Lihat juga Kesalahan Umum di Referensi Amazon DynamoDB API. Referensi API juga menyediakan kesalahan yang tepat untuk setiap operasi API, seperti untuk Queryoperasi. Untuk informasi tentang menangani pengecualian, lihat Penanganan pengecualian untuk Panduan AWS SDK for Java 2.x Pengembang. AWS SDK for Java 2.x

AWS ID permintaan

Setiap permintaan menyertakan ID permintaan, yang dapat berguna untuk ditarik jika Anda bekerja dengan AWS Support untuk mendiagnosis masalah. Setiap pengecualian yang berasal dari SdkServiceException memiliki requestId()metode yang tersedia untuk mengambil ID permintaan.

Pencatatan log

Menggunakan logging asalkan SDK menyediakan dapat berguna baik untuk menangkap pesan penting dari pustaka klien dan untuk tujuan debugging yang lebih mendalam. Logger bersifat hierarkis dan SDK digunakan software.amazon.awssdk sebagai root logger-nya. Anda dapat mengkonfigurasi level dengan salah satu dariTRACE,DEBUG,INFO,WARN,ERROR,ALL, atauOFF. Level yang dikonfigurasi berlaku untuk logger itu dan turun ke hierarki logger.

Untuk logging nya, AWS SDK for Java 2.x menggunakan Simple Logging Façade for Java (SLF4J). Ini bertindak sebagai lapisan abstraksi di sekitar logger lain, dan Anda dapat menggunakannya untuk mencolokkan logger yang Anda inginkan. Untuk petunjuk tentang memasukkan logger, lihat panduan pengguna SLF4J.

Setiap logger memiliki perilaku tertentu. Secara default, logger Log4j 2.x membuatConsoleAppender, yang menambahkan peristiwa log ke System.out dan default ke tingkat log. ERROR

SimpleLogger Logger yang disertakan dalam output SLF4J secara default ke System.err dan default ke tingkat log. INFO

Sebaiknya Anda mengatur level WARN untuk setiap penerapan produksi software.amazon.awssdk untuk menangkap pesan penting apa pun dari pustaka klien SDK sambil membatasi kuantitas keluaran.

Jika SLF4J tidak dapat menemukan logger yang didukung di jalur kelas (tidak ada pengikatan SLF4J), maka defaultnya adalah implementasi tanpa operasi. Implementasi ini menghasilkan pencatatan pesan untuk System.err menjelaskan bahwa SLF4J tidak dapat menemukan implementasi logger di classpath. Untuk mencegah situasi ini, Anda harus menambahkan implementasi logger. Untuk melakukan ini, Anda dapat menambahkan ketergantungan di Apache Maven Anda pom.xml pada artefak, seperti atau. org.slf4j.slf4j-simple org.apache.logging.log4j.log4j-slf4j2-imp

Untuk informasi tentang cara mengonfigurasi logging di SDK, termasuk menambahkan dependensi logging ke konfigurasi aplikasi Anda, lihat Logging dengan SDK for Java 2.x di Panduan Pengembang.AWS SDK for Java

Konfigurasi berikut dalam Log4j2.xml file menunjukkan cara menyesuaikan perilaku logging jika Anda menggunakan logger Apache Log4j 2. Konfigurasi ini menetapkan level root logger keWARN. Semua logger dalam hierarki mewarisi level log ini, termasuk logger. software.amazon.awssdk

Secara default, output masuk keSystem.out. Dalam contoh berikut, kita masih mengganti appender Log4j keluaran default untuk menerapkan log4j yang disesuaikan. PatternLayout

Contoh file Log4j2.xml konfigurasi

Konfigurasi berikut mencatat pesan ke konsol di WARN tingkat ERROR dan untuk semua hierarki logger.

<Configuration status="WARN">
  <Appenders>
    <Console name="ConsoleAppender" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{YYYY-MM-dd HH:mm:ss} [%t] %-5p %c:%L - %m%n" />
    </Console>
  </Appenders>

  <Loggers>
    <Root level="WARN">
      <AppenderRef ref="ConsoleAppender"/>
    </Root>
  </Loggers>
</Configuration>

AWS minta pencatatan ID

Ketika terjadi kesalahan, Anda dapat menemukan ID permintaan dalam pengecualian. Namun, jika Anda menginginkan ID permintaan untuk permintaan yang tidak menghasilkan pengecualian, Anda dapat menggunakan logging.

Output software.amazon.awssdk.request logger meminta ID di level tersebut. DEBUG Contoh berikut memperluas sebelumnya configuration example untuk menjaga level root logger padaERROR, level atWARN, dan level at. software.amazon.awssdk software.amazon.awssdk.request DEBUG Menyetel level ini membantu menangkap ID permintaan dan detail terkait permintaan lainnya, seperti titik akhir dan kode status.

<Configuration status="WARN">
  <Appenders>
    <Console name="ConsoleAppender" target="SYSTEM_OUT">
      <PatternLayout pattern="%d{YYYY-MM-dd HH:mm:ss} [%t] %-5p %c:%L - %m%n" />
    </Console>
  </Appenders>

  <Loggers>
    <Root level="ERROR">
      <AppenderRef ref="ConsoleAppender"/>
    </Root>
    <Logger name="software.amazon.awssdk" level="WARN" />
    <Logger name="software.amazon.awssdk.request" level="DEBUG" />
  </Loggers>
</Configuration>

Berikut adalah contoh output log:

2022-09-23 16:02:08 [main] DEBUG software.amazon.awssdk.request:85 - Sending Request: DefaultSdkHttpFullRequest(httpMethod=POST, protocol=https, host=dynamodb.us-east-1.amazonaws.com, encodedPath=/, headers=[amz-sdk-invocation-id, Content-Length, Content-Type, User-Agent, X-Amz-Target], queryParameters=[])
 2022-09-23 16:02:08 [main] DEBUG software.amazon.awssdk.request:85 - Received successful response: 200, Request ID: QS9DUMME2NHEDH8TGT9N5V53OJVV4KQNSO5AEMVJF66Q9ASUAAJG, Extended Request ID: not available

Paginasi

Beberapa permintaan, seperti Querydan Scan, membatasi ukuran data yang dikembalikan pada satu permintaan dan mengharuskan Anda membuat permintaan berulang untuk menarik halaman berikutnya.

Anda dapat mengontrol jumlah maksimum item untuk dibaca untuk setiap halaman dengan Limit parameter. Misalnya, Anda dapat menggunakan Limit parameter untuk mengambil hanya 10 item terakhir. Batas ini menentukan berapa banyak item untuk membaca dari tabel sebelum penyaringan diterapkan. Jika Anda menginginkan tepat 10 item setelah pemfilteran, tidak ada cara untuk menentukannya. Anda hanya dapat mengontrol jumlah yang telah difilter sebelumnya dan memeriksa sisi klien saat Anda benar-benar mengambil 10 item. Terlepas dari batasnya, respons selalu memiliki ukuran maksimum 1 MB.

A LastEvaluatedKey mungkin disertakan dalam respons API. Ini menunjukkan bahwa respons berakhir karena mencapai batas hitungan atau batas ukuran. Kunci ini adalah kunci terakhir yang dievaluasi untuk respons itu. Dengan berinteraksi langsung dengan API, Anda dapat mengambil ini LastEvaluatedKey dan meneruskannya ke panggilan tindak lanjut ExclusiveStartKey untuk membaca potongan berikutnya dari titik awal itu. Jika no LastEvaluatedKey dikembalikan, itu berarti tidak ada lagi item yang cocok dengan panggilan Scan API Query atau.

Contoh berikut menggunakan antarmuka tingkat rendah untuk membatasi item hingga 100 berdasarkan keyConditionExpression parameter.

QueryRequest.Builder queryRequestBuilder = QueryRequest.builder()
        .expressionAttributeValues(Map.of(
                ":pk_val", AttributeValue.fromS("123"),
                ":sk_val", AttributeValue.fromN("1000")))
        .keyConditionExpression("pk = :pk_val AND sk > :sk_val")
        .limit(100)
        .tableName(TABLE_NAME);

while (true) {
    QueryResponse queryResponse = DYNAMODB_CLIENT.query(queryRequestBuilder.build());

    queryResponse.items().forEach(item -> {
        LOGGER.info("item PK: [" + item.get("pk") + "] and SK: [" + item.get("sk") + "]");
    });

    if (!queryResponse.hasLastEvaluatedKey()) {
        break;
    }
    queryRequestBuilder.exclusiveStartKey(queryResponse.lastEvaluatedKey());
}

Ini AWS SDK for Java 2.x dapat menyederhanakan interaksi ini dengan DynamoDB dengan menyediakan metode pagination otomatis yang membuat beberapa panggilan layanan untuk secara otomatis mendapatkan halaman hasil berikutnya untuk Anda. Ini menyederhanakan kode Anda, tetapi menghilangkan beberapa kontrol penggunaan sumber daya yang akan Anda simpan dengan membaca halaman secara manual.

Dengan menggunakan Iterable metode yang tersedia di klien DynamoDB, QueryPaginatorseperti ScanPaginatordan, SDK menangani pagination. Jenis pengembalian metode ini adalah iterable khusus yang dapat Anda gunakan untuk mengulangi semua halaman. SDK secara internal menangani panggilan layanan untuk Anda. Menggunakan Java Stream API, Anda dapat menangani hasil QueryPaginator seperti yang ditunjukkan pada contoh berikut.

QueryPublisher queryPublisher =
    DYNAMODB_CLIENT.queryPaginator(QueryRequest.builder()
        .expressionAttributeValues(Map.of(
            ":pk_val", AttributeValue.fromS("123"),
            ":sk_val", AttributeValue.fromN("1000")))
        .keyConditionExpression("pk = :pk_val AND sk > :sk_val")
        .limit(100)
        .tableName("YourTableName")
        .build());

queryPublisher.items().subscribe(item ->
    System.out.println(item.get("itemData"))).join();

Anotasi kelas data

Java SDK menyediakan beberapa anotasi yang dapat Anda masukkan pada atribut kelas data Anda. Anotasi ini memengaruhi cara SDK berinteraksi dengan atribut. Dengan menambahkan anotasi, Anda dapat memiliki atribut yang berperilaku sebagai penghitung atom implisit, mempertahankan nilai stempel waktu yang dibuat secara otomatis, atau melacak nomor versi item. Untuk informasi selengkapnya, lihat Anotasi kelas data.