# Java 1.x: DynamoDBMapper
<a name="DynamoDBMapper"></a>

**nota**  
El SDK para Java tiene dos versiones: 1.x y 2.x. El 12 de enero de 2024 se [anunció](https://aws.amazon.com/blogs/developer/announcing-end-of-support-for-aws-sdk-for-java-v1-x-on-december-31-2025/) el fin de soporte de la versión 1.x. Lo hará y está previsto que se dé por terminado el 31 de diciembre de 2025. Para nuevos desarrollos, recomendamos encarecidamente el uso de 2.x.

El AWS SDK para Java proporciona la clase `DynamoDBMapper` que permite mapear las clases del lado del cliente a las tablas de Amazon DynamoDB. Para usar `DynamoDBMapper`, se define la relación entre los elementos de una tabla de DynamoDB y sus instancias de objetos correspondientes en el código. La clase `DynamoDBMapper` permite realizar varias operaciones de creación, lectura, actualización y eliminación (CRUD, Create, Read, Update y Delete) en elementos y ejecutar consultas y análisis en tablas.

**Topics**
+ [Clase DynamoDBMapper](DynamoDBMapper.Methods.md)
+ [Tipos de datos compatibles con asignador DynamoDBMapper para Java](DynamoDBMapper.DataTypes.md)
+ [Anotaciones de Java para DynamoDB](DynamoDBMapper.Annotations.md)
+ [Ajustes de configuración opcionales para DynamoDBMapper](DynamoDBMapper.OptionalConfig.md)
+ [DynamoDB y bloqueo positivo con el número de versión](DynamoDBMapper.OptimisticLocking.md)
+ [Asignación de datos arbitrarios en DynamoDB](DynamoDBMapper.ArbitraryDataMapping.md)
+ [Ejemplos de DynamoDBMapper](DynamoDBMapper.Examples.md)

**nota**  
La clase `DynamoDBMapper` no permite crear, actualizar o eliminar tablas. Para realizar estas tareas, utilice la interfaz de bajo nivel del SDK para Java en su lugar.

El SDK para Java proporciona un conjunto de tipos de anotación para que pueda mapear las clases de tablas. Por ejemplo, tomemos una tabla `ProductCatalog` cuya clave de partición es `Id`. 

```
ProductCatalog(Id, ...)
```

Puede mapear una clase de la aplicación cliente a la tabla `ProductCatalog` tal y como se muestra en el siguiente código Java. En este código se define un objeto Java estándar (POJO) denominado `CatalogItem` que utiliza anotaciones para mapear campos de objetos a nombres de atributos de DynamoDB.

**Example**  

```
package com.amazonaws.codesamples;

import java.util.Set;

import software.amazon.dynamodb.datamodeling.DynamoDBAttribute;
import software.amazon.dynamodb.datamodeling.DynamoDBHashKey;
import software.amazon.dynamodb.datamodeling.DynamoDBIgnore;
import software.amazon.dynamodb.datamodeling.DynamoDBTable;

@DynamoDBTable(tableName="ProductCatalog")
public class CatalogItem {

    private Integer id;
    private String title;
    private String ISBN;
    private Set<String> bookAuthors;
    private String someProp;

    @DynamoDBHashKey(attributeName="Id")
    public Integer getId() { return id; }
    public void setId(Integer id) {this.id = id; }

    @DynamoDBAttribute(attributeName="Title")
    public String getTitle() {return title; }
    public void setTitle(String title) { this.title = title; }

    @DynamoDBAttribute(attributeName="ISBN")
    public String getISBN() { return ISBN; }
    public void setISBN(String ISBN) { this.ISBN = ISBN; }

    @DynamoDBAttribute(attributeName="Authors")
    public Set<String> getBookAuthors() { return bookAuthors; }
    public void setBookAuthors(Set<String> bookAuthors) { this.bookAuthors = bookAuthors; }

    @DynamoDBIgnore
    public String getSomeProp() { return someProp; }
    public void setSomeProp(String someProp) { this.someProp = someProp; }
}
```

En el código anterior, la anotación `@DynamoDBTable` mapea la clase `CatalogItem` a la tabla `ProductCatalog`. Puede almacenar instancias de clases individuales como los elementos de la tabla. En la definición de clase, la anotación `@DynamoDBHashKey` mapea la propiedad `Id` a la clave principal. 

De forma predeterminada, las propiedades de la clase se mapean a los atributos de la tabla que tienen el mismo nombre. Las propiedades `Title` e `ISBN` se mapean a los atributos de la tabla que tienen el mismo nombre. 

La anotación `@DynamoDBAttribute` es opcional cuando el nombre del atributo de DynamoDB coincide con el nombre de la propiedad declarada en la clase. Si son distintos, use esta anotación con el parámetro `attributeName` para especificar qué atributo de DynamoDB se corresponde con esta propiedad. 

En el ejemplo anterior, la anotación `@DynamoDBAttribute` se agrega a cada propiedad para garantizar que los nombres de las propiedades coincidan exactamente con las tablas creadas en un paso anterior y para mantener la coherencia con los nombres de atributo utilizados en otros ejemplos de código de esta guía. 

La definición de clase puede tener propiedades que no se mapeen a ningún atributo de la tabla. Estas propiedades se identifican agregándoles la anotación `@DynamoDBIgnore`. En el ejemplo anterior, la propiedad `SomeProp` se ha marcado con la anotación `@DynamoDBIgnore`. Al cargar una instancia de `CatalogItem` en la tabla, la instancia de `DynamoDBMapper` no incluye la propiedad `SomeProp`. Tampoco el mapeador devuelve este atributo cuando se recupera un elemento de la tabla. 

Después de haber definido la clase de mapeo, puede usar métodos `DynamoDBMapper` para escribir una instancia de esa clase en un elemento correspondiente de la tabla `Catalog`. En el siguiente ejemplo de código se muestra esta técnica.

```
AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard().build();

DynamoDBMapper mapper = new DynamoDBMapper(client);

CatalogItem item = new CatalogItem();
item.setId(102);
item.setTitle("Book 102 Title");
item.setISBN("222-2222222222");
item.setBookAuthors(new HashSet<String>(Arrays.asList("Author 1", "Author 2")));
item.setSomeProp("Test");

mapper.save(item);
```

En el siguiente ejemplo de código se muestra cómo recuperar el elemento y obtener acceso a algunos de sus atributos.

```
CatalogItem partitionKey = new CatalogItem();

partitionKey.setId(102);
DynamoDBQueryExpression<CatalogItem> queryExpression = new DynamoDBQueryExpression<CatalogItem>()
    .withHashKeyValues(partitionKey);

List<CatalogItem> itemList = mapper.query(CatalogItem.class, queryExpression);

for (int i = 0; i < itemList.size(); i++) {
    System.out.println(itemList.get(i).getTitle());
    System.out.println(itemList.get(i).getBookAuthors());
}
```

`DynamoDBMapper` ofrece un modo natural e intuitivo de usar los datos de DynamoDB en Java. También ofrece varias características integradas, tales como el bloqueo optimista, las transacciones ACID, la generación automática de valores de claves de partición y de orden y el control de versiones de objetos.