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

# Menggunakan DAX dengan AWS SDK for Java 1.x
<a name="DAX.client.java-sdk-v1"></a>

Ikuti prosedur ini untuk menjalankan sampel Java untuk Amazon DynamoDB Accelerator (DAX) di instans Amazon Anda. EC2

**catatan**  
Instruksi ini untuk aplikasi yang menggunakan AWS SDK for Java 1.x. Untuk aplikasi yang menggunakan AWS SDK untuk Java 2.x, lihat [Java dan DAX](DAX.client.run-application-java.md).

**Cara menjalankan sampel Java untuk DAX**

1. Instal Java Development Kit (JDK).

   ```
   sudo yum install -y java-devel
   ```

1. Unduh AWS SDK untuk Java (`.zip`file), lalu ekstrak.

   ```
   wget http://sdk-for-java.amazonwebservices.com/latest/aws-java-sdk.zip
   
   unzip aws-java-sdk.zip
   ```

1. Unduh versi terbaru dari klien DAX Java (file `.jar`).

   ```
   wget http://dax-sdk.s3-website-us-west-2.amazonaws.com/java/DaxJavaClient-latest.jar
   ```
**catatan**  
Klien untuk DAX SDK untuk Java tersedia di Apache Maven. Untuk informasi selengkapnya, lihat [Menggunakan klien sebagai dependensi Apache Maven](#DAXClient.Maven).

1. Atur variabel `CLASSPATH` Anda. Dalam contoh ini, ganti `sdkVersion` dengan nomor versi aktual dari AWS SDK untuk Java (misalnya,`1.11.112`).

   ```
   export SDKVERSION=sdkVersion
   
   export CLASSPATH=$(pwd)/TryDax/java:$(pwd)/DaxJavaClient-latest.jar:$(pwd)/aws-java-sdk-$SDKVERSION/lib/aws-java-sdk-$SDKVERSION.jar:$(pwd)/aws-java-sdk-$SDKVERSION/third-party/lib/*
   ```

1. Unduh sampel kode sumber program (file `.zip`).

   ```
   wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip
   ```

   Setelah unduhan selesai, ekstrak file sumber.

   ```
   unzip TryDax.zip
   ```

1. Buka direktori kode Java dan kompilasi kode sebagai berikut.

   ```
   cd TryDax/java/
   javac TryDax*.java
   ```

1. Jalankan program.

   ```
   java TryDax
   ```

   Anda akan melihat output seperti yang berikut ini.

   ```
   Creating a DynamoDB client
   
   Attempting to create table; please wait...
   Successfully created table.  Table status: ACTIVE
   Writing data to the table...
   Writing 10 items for partition key: 1
   Writing 10 items for partition key: 2
   Writing 10 items for partition key: 3
   Writing 10 items for partition key: 4
   Writing 10 items for partition key: 5
   Writing 10 items for partition key: 6
   Writing 10 items for partition key: 7
   Writing 10 items for partition key: 8
   Writing 10 items for partition key: 9
   Writing 10 items for partition key: 10
   
   Running GetItem, Scan, and Query tests...
   First iteration of each test will result in cache misses
   Next iterations are cache hits
   
   GetItem test - partition key 1 and sort keys 1-10
   	Total time: 136.681 ms - Avg time: 13.668 ms
   	Total time: 122.632 ms - Avg time: 12.263 ms
   	Total time: 167.762 ms - Avg time: 16.776 ms
   	Total time: 108.130 ms - Avg time: 10.813 ms
   	Total time: 137.890 ms - Avg time: 13.789 ms
   Query test - partition key 5 and sort keys between 2 and 9
   	Total time: 13.560 ms - Avg time: 2.712 ms
   	Total time: 11.339 ms - Avg time: 2.268 ms
   	Total time: 7.809 ms - Avg time: 1.562 ms
   	Total time: 10.736 ms - Avg time: 2.147 ms
   	Total time: 12.122 ms - Avg time: 2.424 ms
   Scan test - all items in the table
   	Total time: 58.952 ms - Avg time: 11.790 ms
   	Total time: 25.507 ms - Avg time: 5.101 ms
   	Total time: 37.660 ms - Avg time: 7.532 ms
   	Total time: 26.781 ms - Avg time: 5.356 ms
   	Total time: 46.076 ms - Avg time: 9.215 ms
   
   Attempting to delete table; please wait...
   Successfully deleted table.
   ```

   Perhatikan informasi waktu, yaitu jumlah milidetik yang diperlukan untuk pengujian `GetItem`, `Query`, dan `Scan`.

1. Pada langkah sebelumnya, Anda menjalankan program terhadap titik akhir DynamoDB. Sekarang jalankan program lagi, tetapi kali ini, operasi `GetItem`, `Query` dan `Scan` diproses oleh klaster DAX Anda.

   Untuk menentukan titik akhir klaster DAX Anda, pilih salah satu dari berikut ini:
   + **Menggunakan konsol DynamoDB** — Pilih klaster DAX Anda. Titik akhir klaster ditampilkan pada konsol, seperti dalam contoh berikut.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Menggunakan AWS CLI** — Masukkan perintah berikut.

     ```
     aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"
     ```

     Titik akhir klaster ditampilkan pada output, seperti dalam contoh berikut.

     ```
     {
         "Address": "my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com",
         "Port": 8111,
         "URL": "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
     }
     ```

   Sekarang jalankan program lagi, tetapi kali ini tentukan titik akhir klaster sebagai parameter baris perintah.

   ```
   java TryDax dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
   ```

   Periksa sisa output dan perhatikan informasi waktu. Waktu berlalu untuk `GetItem`, `Query`, dan `Scan` harus jauh lebih rendah dengan DAX dibandingkan dengan DynamoDB.

Untuk informasi selengkapnya tentang program ini, lihat bagian berikut:
+ [TryDax.jawa](DAX.client.run-application-java.TryDax.md)
+ [TryDaxHelper.jawa](DAX.client.run-application-java.TryDaxHelper.md)
+ [TryDaxTests.jawa](DAX.client.run-application-java.TryDaxTests.md)

## Menggunakan klien sebagai dependensi Apache Maven
<a name="DAXClient.Maven"></a>

Ikuti langkah-langkah berikut untuk menggunakan klien untuk DAX SDK untuk Java dalam aplikasi Anda sebagai dependensi.

**Cara menggunakan klien sebagai dependensi Maven**

1. Unduh dan instal Apache Maven. Untuk informasi selengkapnya, lihat [Mengunduh Apache Maven](https://maven.apache.org/download.cgi) dan [Menginstal Apache Maven](https://maven.apache.org/install.html).

1. Tambahkan dependensi Maven klien ke file Project Object Model (POM) aplikasi Anda. Dalam contoh ini, ganti `x.x.x.x` dengan nomor versi klien sebenarnya (misalnya, `1.0.200704.0`).

   ```
   <!--Dependency:-->
   <dependencies>
       <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>amazon-dax-client</artifactId>
        <version>x.x.x.x</version>
       </dependency>
   </dependencies>
   ```

# TryDax.jawa
<a name="DAX.client.run-application-java.TryDax"></a>

File `TryDax.java` berisi metode `main`. Jika Anda menjalankan program tanpa parameter baris perintah, klien Amazon DynamoDB akan dibuat dan digunakan untuk semua operasi API. Jika Anda menentukan titik akhir klaster DynamoDB Accelerator (DAX) pada baris perintah, program juga membuat klien DAX dan menggunakannya untuk operasi `GetItem`, `Query`, dan `Scan`.

Anda dapat memodifikasi program dengan beberapa cara:
+ Menggunakan klien DAX, bukan klien DynamoDB. Untuk informasi selengkapnya, lihat [Java dan DAX](DAX.client.run-application-java.md).
+ Memilih nama yang berbeda untuk tabel pengujian.
+ Memodifikasi jumlah item yang ditulis dengan mengubah parameter `helper.writeData`. Parameter kedua adalah angka kunci partisi dan parameter ketiga adalah kunci urutan. Secara default, program menggunakan 1-10 untuk nilai kunci partisi dan 1-10 untuk nilai kunci urutan, dengan total 100 item yang ditulis ke tabel. Untuk informasi selengkapnya, lihat [TryDaxHelper.jawa](DAX.client.run-application-java.TryDaxHelper.md).
+ Memodifikasi jumlah pengujian `GetItem`, `Query`, dan `Scan`, serta memodifikasi parameternya.
+ Mengomentari baris yang berisi `helper.createTable` dan `helper.deleteTable` (jika Anda tidak ingin membuat dan menghapus tabel setiap kali menjalankan program).

**catatan**  
Untuk menjalankan program ini, Anda dapat mengatur Maven untuk menggunakan klien untuk DAX SDK for Java dan dependensi as. AWS SDK untuk Java Untuk informasi selengkapnya, lihat [Menggunakan klien sebagai dependensi Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Selain itu, Anda juga dapat mengunduh dan menyertakan klien DAX Java dan AWS SDK untuk Java di classpath Anda. Lihat [Java dan DAX](DAX.client.run-application-java.md) untuk contoh pengaturan variabel `CLASSPATH`.

```
public class TryDax {

    public static void main(String[] args) throws Exception {

        TryDaxHelper helper = new TryDaxHelper();
        TryDaxTests tests = new TryDaxTests();

        DynamoDB ddbClient = helper.getDynamoDBClient();
        DynamoDB daxClient = null;
        if (args.length >= 1) {
            daxClient = helper.getDaxClient(args[0]);
        }

        String tableName = "TryDaxTable";

        System.out.println("Creating table...");
        helper.createTable(tableName, ddbClient);
        System.out.println("Populating table...");
        helper.writeData(tableName, ddbClient, 10, 10);

        DynamoDB testClient = null;
        if (daxClient != null) {
            testClient = daxClient;
        } else {
            testClient = ddbClient;
        }

        System.out.println("Running GetItem, Scan, and Query tests...");
        System.out.println("First iteration of each test will result in cache misses");
        System.out.println("Next iterations are cache hits\n");

        // GetItem
        tests.getItemTest(tableName, testClient, 1, 10, 5);

        // Query
        tests.queryTest(tableName, testClient, 5, 2, 9, 5);

        // Scan
        tests.scanTest(tableName, testClient, 5);

        helper.deleteTable(tableName, ddbClient);
    }

}
```

# TryDaxHelper.jawa
<a name="DAX.client.run-application-java.TryDaxHelper"></a>

File `TryDaxHelper.java` berisi metode utilitas.

Metode `getDynamoDBClient` dan `getDaxClient` menyediakan klien untuk Amazon DynamoDB dan DynamoDB Accelerator (DAX). Untuk operasi bidang kontrol (`CreateTable`, `DeleteTable`) dan operasi penulisan, program menggunakan klien DynamoDB. Jika Anda menentukan titik akhir klaster DAX, program utama membuat klien DAX untuk melakukan operasi baca (`GetItem`, `Query`, `Scan`).

Metode `TryDaxHelper` lainnya (`createTable`, `writeData`, `deleteTable`) digunakan untuk mengatur dan menghapus tabel DynamoDB dan datanya.

Anda dapat memodifikasi program dengan beberapa cara:
+ Menggunakan pengaturan throughput lain yang disediakan untuk tabel.
+ Memodifikasi ukuran setiap item yang ditulis (lihat variabel `stringSize` di metode `writeData`).
+ Memodifikasi jumlah pengujian `GetItem`, `Query`, dan `Scan` serta parameternya.
+ Mengomentari baris yang berisi `helper.CreateTable` dan `helper.DeleteTable` (jika Anda tidak ingin membuat dan menghapus tabel setiap kali menjalankan program).

**catatan**  
 Untuk menjalankan program ini, Anda dapat mengatur Maven untuk menggunakan klien untuk DAX SDK for Java dan dependensi as. AWS SDK untuk Java Untuk informasi selengkapnya, lihat [Menggunakan klien sebagai dependensi Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Atau, Anda dapat mengunduh dan menyertakan klien DAX Java dan AWS SDK untuk Java di classpath Anda. Lihat [Java dan DAX](DAX.client.run-application-java.md) untuk contoh pengaturan variabel `CLASSPATH`.

```
import com.amazon.dax.client.dynamodbv2.AmazonDaxClientBuilder;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
import com.amazonaws.services.dynamodbv2.model.KeyType;
import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
import com.amazonaws.services.dynamodbv2.model.ScalarAttributeType;
import com.amazonaws.util.EC2MetadataUtils;

public class TryDaxHelper {

    private static final String region = EC2MetadataUtils.getEC2InstanceRegion();

    DynamoDB getDynamoDBClient() {
        System.out.println("Creating a DynamoDB client");
        AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()
                .withRegion(region)
                .build();
        return new DynamoDB(client);
    }

    DynamoDB getDaxClient(String daxEndpoint) {
        System.out.println("Creating a DAX client with cluster endpoint " + daxEndpoint);
        AmazonDaxClientBuilder daxClientBuilder = AmazonDaxClientBuilder.standard();
        daxClientBuilder.withRegion(region).withEndpointConfiguration(daxEndpoint);
        AmazonDynamoDB client = daxClientBuilder.build();
        return new DynamoDB(client);
    }

    void createTable(String tableName, DynamoDB client) {
        Table table = client.getTable(tableName);
        try {
            System.out.println("Attempting to create table; please wait...");

            table = client.createTable(tableName,
                    Arrays.asList(
                            new KeySchemaElement("pk", KeyType.HASH), // Partition key
                            new KeySchemaElement("sk", KeyType.RANGE)), // Sort key
                    Arrays.asList(
                            new AttributeDefinition("pk", ScalarAttributeType.N),
                            new AttributeDefinition("sk", ScalarAttributeType.N)),
                    new ProvisionedThroughput(10L, 10L));
            table.waitForActive();
            System.out.println("Successfully created table.  Table status: " +
                    table.getDescription().getTableStatus());

        } catch (Exception e) {
            System.err.println("Unable to create table: ");
            e.printStackTrace();
        }
    }

    void writeData(String tableName, DynamoDB client, int pkmax, int skmax) {
        Table table = client.getTable(tableName);
        System.out.println("Writing data to the table...");

        int stringSize = 1000;
        StringBuilder sb = new StringBuilder(stringSize);
        for (int i = 0; i < stringSize; i++) {
            sb.append('X');
        }
        String someData = sb.toString();

        try {
            for (Integer ipk = 1; ipk <= pkmax; ipk++) {
                System.out.println(("Writing " + skmax + " items for partition key: " + ipk));
                for (Integer isk = 1; isk <= skmax; isk++) {
                    table.putItem(new Item()
                            .withPrimaryKey("pk", ipk, "sk", isk)
                            .withString("someData", someData));
                }
            }
        } catch (Exception e) {
            System.err.println("Unable to write item:");
            e.printStackTrace();
        }
    }

    void deleteTable(String tableName, DynamoDB client) {
        Table table = client.getTable(tableName);
        try {
            System.out.println("\nAttempting to delete table; please wait...");
            table.delete();
            table.waitForDelete();
            System.out.println("Successfully deleted table.");

        } catch (Exception e) {
            System.err.println("Unable to delete table: ");
            e.printStackTrace();
        }
    }

}
```

# TryDaxTests.jawa
<a name="DAX.client.run-application-java.TryDaxTests"></a>

File `TryDaxTests.java` berisi metode yang melakukan operasi pembacaan terhadap tabel pengujian di Amazon DynamoDB. Metode ini tidak peduli dengan cara data diakses (menggunakan klien DynamoDB atau klien DAX), sehingga tidak memerlukan modifikasi logika aplikasi.

Anda dapat memodifikasi program dengan beberapa cara:
+ Memodifikasi metode `queryTest` agar menggunakan `KeyConditionExpression` yang berbeda.
+ Menambahkan `ScanFilter` ke metode `scanTest` sehingga hanya beberapa item yang dikembalikan kepada Anda.

**catatan**  
 Untuk menjalankan program ini, Anda dapat mengatur Maven untuk menggunakan klien untuk DAX SDK for Java dan dependensi as. AWS SDK untuk Java Untuk informasi selengkapnya, lihat [Menggunakan klien sebagai dependensi Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Atau, Anda dapat mengunduh dan menyertakan klien DAX Java dan AWS SDK untuk Java di classpath Anda. Lihat [Java dan DAX](DAX.client.run-application-java.md) untuk contoh pengaturan variabel `CLASSPATH`.

```
import java.util.Iterator;

import com.amazonaws.services.dynamodbv2.document.DynamoDB;
import com.amazonaws.services.dynamodbv2.document.Item;
import com.amazonaws.services.dynamodbv2.document.ItemCollection;
import com.amazonaws.services.dynamodbv2.document.QueryOutcome;
import com.amazonaws.services.dynamodbv2.document.ScanOutcome;
import com.amazonaws.services.dynamodbv2.document.Table;
import com.amazonaws.services.dynamodbv2.document.spec.QuerySpec;

public class TryDaxTests {

    void getItemTest(String tableName, DynamoDB client, int pk, int sk, int iterations) {
        long startTime, endTime;
        System.out.println("GetItem test - partition key " + pk + " and sort keys 1-" + sk);
        Table table = client.getTable(tableName);

        for (int i = 0; i < iterations; i++) {
            startTime = System.nanoTime();
            try {
                for (Integer ipk = 1; ipk <= pk; ipk++) {
                    for (Integer isk = 1; isk <= sk; isk++) {
                        table.getItem("pk", ipk, "sk", isk);
                    }
                }
            } catch (Exception e) {
                System.err.println("Unable to get item:");
                e.printStackTrace();
            }
            endTime = System.nanoTime();
            printTime(startTime, endTime, pk * sk);
        }
    }

    void queryTest(String tableName, DynamoDB client, int pk, int sk1, int sk2, int iterations) {
        long startTime, endTime;
        System.out.println("Query test - partition key " + pk + " and sort keys between " + sk1 + " and " + sk2);
        Table table = client.getTable(tableName);

        HashMap<String, Object> valueMap = new HashMap<String, Object>();
        valueMap.put(":pkval", pk);
        valueMap.put(":skval1", sk1);
        valueMap.put(":skval2", sk2);

        QuerySpec spec = new QuerySpec()
                .withKeyConditionExpression("pk = :pkval and sk between :skval1 and :skval2")
                .withValueMap(valueMap);

        for (int i = 0; i < iterations; i++) {
            startTime = System.nanoTime();
            ItemCollection<QueryOutcome> items = table.query(spec);

            try {
                Iterator<Item> iter = items.iterator();
                while (iter.hasNext()) {
                    iter.next();
                }
            } catch (Exception e) {
                System.err.println("Unable to query table:");
                e.printStackTrace();
            }
            endTime = System.nanoTime();
            printTime(startTime, endTime, iterations);
        }
    }

    void scanTest(String tableName, DynamoDB client, int iterations) {
        long startTime, endTime;
        System.out.println("Scan test - all items in the table");
        Table table = client.getTable(tableName);

        for (int i = 0; i < iterations; i++) {
            startTime = System.nanoTime();
            ItemCollection<ScanOutcome> items = table.scan();
            try {

                Iterator<Item> iter = items.iterator();
                while (iter.hasNext()) {
                    iter.next();
                }
            } catch (Exception e) {
                System.err.println("Unable to scan table:");
                e.printStackTrace();
            }
            endTime = System.nanoTime();
            printTime(startTime, endTime, iterations);
        }
    }

    public void printTime(long startTime, long endTime, int iterations) {
        System.out.format("\tTotal time: %.3f ms - ", (endTime - startTime) / (1000000.0));
        System.out.format("Avg time: %.3f ms\n", (endTime - startTime) / (iterations * 1000000.0));
    }
}
```