# Uso do DAX com o AWS SDK for Java 1.x
<a name="DAX.client.java-sdk-v1"></a>

Siga este procedimento para executar o exemplo de Java para o Amazon DynamoDB Accelerator (DAX) na instância do Amazon EC2.

**nota**  
Estas instruções destinam-se a aplicações que usam o AWS SDK for Java 1.x. Para aplicações que usam o AWS SDK for Java 2.x, consulte [Java e DAX](DAX.client.run-application-java.md).

**Como executar o exemplo de Java para DAX**

1. Instale o Java Development Kit (JDK).

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

1. Faça download do AWS SDK para Java (arquivo `.zip`) e extraia-o.

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

1. Baixe a versão mais recente do cliente Java do DAX (arquivo `.jar`).

   ```
   wget http://dax-sdk.s3-website-us-west-2.amazonaws.com/java/DaxJavaClient-latest.jar
   ```
**nota**  
O cliente do SDK for Java do DAX está disponível no Apache Maven. Para ter mais informações, consulte [Usar o cliente como dependência do Apache Maven](#DAXClient.Maven).

1. Defina a variável `CLASSPATH`. Neste exemplo, substitua `sdkVersion` pelo número da versão atual do AWS SDK para Java (por exemplo, `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. Baixe o código-fonte do programa de exemplo (arquivo `.zip`).

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

   Quando o download for concluído, extraia os arquivos de origem.

   ```
   unzip TryDax.zip
   ```

1. Navegue até o diretório de código Java e compile o código conforme descrito a seguir.

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

1. Execute o programa.

   ```
   java TryDax
   ```

   Você deve ver saída semelhante ao seguinte:

   ```
   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.
   ```

   Anote as informações de tempo: o número de milissegundos necessários para os testes `GetItem`, `Query` e `Scan`.

1. Na etapa anterior, você executou o programa no endpoint do DynamoDB. Agora, execute o programa novamente, mas, desta vez, as operações `GetItem`, `Query` e `Scan` são processadas pelo cluster do DAX.

   Para determinar o endpoint do cluster do DAX, escolha uma das seguintes opções:
   + **Usando o console do DynamoDB**: escolha seu cluster do DAX. O endpoint do cluster é mostrado no console, como no exemplo a seguir.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Usando a AWS CLI**: insira o comando a seguir.

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

     O endpoint do cluster é mostrado na saída, como no exemplo a seguir.

     ```
     {
         "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"
     }
     ```

   Agora execute o programa novamente, mas, desta vez, especifique o endpoint do cluster como um parâmetro de linha de comando.

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

   Observe o restante da saída e anote as informações de tempo. Os tempos decorridos para `GetItem`, `Query` e `Scan` devem ser significativamente mais baixos com o DAX do que com o DynamoDB.

Para obter mais informações sobre esse programa, consulte as seguintes seções:
+ [TryDax.java](DAX.client.run-application-java.TryDax.md)
+ [TryDaxHelper.java](DAX.client.run-application-java.TryDaxHelper.md)
+ [TryDaxTests.java](DAX.client.run-application-java.TryDaxTests.md)

## Usar o cliente como dependência do Apache Maven
<a name="DAXClient.Maven"></a>

Siga estas etapas para usar o cliente do SDK do DAX para Java em seu aplicativo como uma dependência.

**Como usar o cliente como uma dependência do Maven**

1. Faça download do Apache Maven e instale-o. Para obter mais informações, consulte [Download do Apache Maven](https://maven.apache.org/download.cgi) e [Instalação do Apache Maven](https://maven.apache.org/install.html).

1. Adicione a dependência do cliente Maven ao arquivo Project Object Model (POM) da aplicação. Neste exemplo, substitua `x.x.x.x` pelo número da versão real do cliente (por exemplo, `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.java
<a name="DAX.client.run-application-java.TryDax"></a>

O arquivo `TryDax.java` contém o método `main`. Se você executar o programa sem parâmetros de linha de comando, ele criará um cliente do Amazon DynamoDB e usará esse cliente para todas as operações de API. Se você especificar um endpoint de cluster do DynamoDB Accelerator (DAX) na linha de comando, o programa também criará um cliente do DAX e o usará para operações `GetItem`, `Query` e `Scan`.

É possível modificar o programa de várias maneiras:
+ Use o cliente do DAX em vez do cliente do DynamoDB. Para ter mais informações, consulte [Java e DAX](DAX.client.run-application-java.md).
+ Escolha um nome diferente para a tabela de teste.
+ Modifique o número de itens gravados, alterando os parâmetros `helper.writeData`. O segundo parâmetro é o número de chaves de partição, e o terceiro parâmetro é o número de chaves de classificação. Por padrão, o programa usa 1–10 para valores de chave de partição e 1–10 para valores de chave de classificação, totalizando 100 itens gravados na tabela. Para ter mais informações, consulte [TryDaxHelper.java](DAX.client.run-application-java.TryDaxHelper.md).
+ Modifique o número de testes de `GetItem`, `Query` e `Scan` e modifique seus parâmetros.
+ Assinale como comentários as linhas contendo `helper.createTable` e `helper.deleteTable` (se não quiser criar e excluir a tabela de cada vez que executar o programa).

**nota**  
Para executar o programa, é possível configurar o Maven para usar o cliente do SDK for Java do DAX e o AWS SDK para Java como dependências. Para ter mais informações, consulte [Usar o cliente como dependência do Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Opcionalmente, você pode fazer download e incluir o cliente Java do DAX e o AWS SDK para Java em seu classpath. Consulte [Java e DAX](DAX.client.run-application-java.md) para obter um exemplo de configuração da variável `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.java
<a name="DAX.client.run-application-java.TryDaxHelper"></a>

O arquivo `TryDaxHelper.java` contém métodos utilitários.

Os métodos `getDynamoDBClient` e `getDaxClient` fornecem clientes do Amazon DynamoDB e DynamoDB Accelerator (DAX). Para operações do plano de controle (`CreateTable`, `DeleteTable`) e operações de gravação, o programa usa o cliente do DynamoDB. Se você especificar um endpoint de cluster do DAX, o programa principal criará um cliente do DAX para realizar operações de leitura (`GetItem`, `Query`, `Scan`).

Os outros métodos de `TryDaxHelper` (`createTable`, `writeData`, `deleteTable`) são para configurar e destruir a tabela do DynamoDB e seus dados.

É possível modificar o programa de várias maneiras:
+ Use configurações de throughput provisionado diferentes para a tabela.
+ Modifique o tamanho de cada item gravado (consulte a variável `stringSize` no método `writeData`).
+ Modifique o número de testes de `GetItem`, `Query` e `Scan` e seus parâmetros.
+ Assinale como comentários as linhas contendo `helper.CreateTable` e `helper.DeleteTable` (se não quiser criar e excluir a tabela de cada vez que executar o programa).

**nota**  
 Para executar o programa, é possível configurar o Maven para usar o cliente do SDK for Java do DAX e o AWS SDK para Java como dependências. Para ter mais informações, consulte [Usar o cliente como dependência do Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Ou você pode fazer download e incluir o cliente Java do DAX e o AWS SDK para Java em seu classpath. Consulte [Java e DAX](DAX.client.run-application-java.md) para obter um exemplo de configuração da variável `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.java
<a name="DAX.client.run-application-java.TryDaxTests"></a>

O arquivo `TryDaxTests.java` contém métodos que executam operações de leitura em uma tabela de teste no Amazon DynamoDB. Esses métodos não consideram como os dados serão acessados (usando o cliente do DynamoDB ou o cliente do DAX) e, portanto, não é necessário modificar a lógica da aplicação.

É possível modificar o programa de várias maneiras:
+ Modifique o método `queryTest` para que ele use um `KeyConditionExpression` diferente.
+ Adicione um `ScanFilter` ao método `scanTest`, para que apenas alguns dos itens sejam retornados para você.

**nota**  
 Para executar o programa, é possível configurar o Maven para usar o cliente do SDK for Java do DAX e o AWS SDK para Java como dependências. Para ter mais informações, consulte [Usar o cliente como dependência do Apache Maven](DAX.client.java-sdk-v1.md#DAXClient.Maven).   
Ou você pode fazer download e incluir o cliente Java do DAX e o AWS SDK para Java em seu classpath. Consulte [Java e DAX](DAX.client.run-application-java.md) para obter um exemplo de configuração da variável `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));
    }
}
```