/*
* Copyright 2011-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://aws.amazon.com/apache2.0
*
* This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES
* OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and
* limitations under the License.
*/
package com.amazonaws.mobileconnectors.dynamodbv2.dynamodbmapper;
import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.AmazonWebServiceRequest;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.mobile.config.AWSConfiguration;
import com.amazonaws.mobileconnectors.dynamodbv2.dynamodbmapper.DynamoDBMapperConfig.ConsistentReads;
import com.amazonaws.mobileconnectors.dynamodbv2.dynamodbmapper.DynamoDBMapperConfig.PaginationLoadingStrategy;
import com.amazonaws.mobileconnectors.dynamodbv2.dynamodbmapper.DynamoDBMapperConfig.SaveBehavior;
import com.amazonaws.mobileconnectors.dynamodbv2.dynamodbmapper.DynamoDBTableSchemaParser.TableIndexesInfo;
import com.amazonaws.retry.RetryUtils;
import com.amazonaws.services.dynamodbv2.AmazonDynamoDB;
import com.amazonaws.services.dynamodbv2.model.AttributeAction;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import com.amazonaws.services.dynamodbv2.model.AttributeValueUpdate;
import com.amazonaws.services.dynamodbv2.model.BatchGetItemRequest;
import com.amazonaws.services.dynamodbv2.model.BatchGetItemResult;
import com.amazonaws.services.dynamodbv2.model.BatchWriteItemRequest;
import com.amazonaws.services.dynamodbv2.model.BatchWriteItemResult;
import com.amazonaws.services.dynamodbv2.model.ComparisonOperator;
import com.amazonaws.services.dynamodbv2.model.Condition;
import com.amazonaws.services.dynamodbv2.model.ConditionalCheckFailedException;
import com.amazonaws.services.dynamodbv2.model.ConditionalOperator;
import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest;
import com.amazonaws.services.dynamodbv2.model.DeleteRequest;
import com.amazonaws.services.dynamodbv2.model.ExpectedAttributeValue;
import com.amazonaws.services.dynamodbv2.model.GetItemRequest;
import com.amazonaws.services.dynamodbv2.model.GetItemResult;
import com.amazonaws.services.dynamodbv2.model.KeysAndAttributes;
import com.amazonaws.services.dynamodbv2.model.PutItemRequest;
import com.amazonaws.services.dynamodbv2.model.PutItemResult;
import com.amazonaws.services.dynamodbv2.model.PutRequest;
import com.amazonaws.services.dynamodbv2.model.QueryRequest;
import com.amazonaws.services.dynamodbv2.model.QueryResult;
import com.amazonaws.services.dynamodbv2.model.ReturnValue;
import com.amazonaws.services.dynamodbv2.model.ScanRequest;
import com.amazonaws.services.dynamodbv2.model.ScanResult;
import com.amazonaws.services.dynamodbv2.model.Select;
import com.amazonaws.services.dynamodbv2.model.UpdateItemRequest;
import com.amazonaws.services.dynamodbv2.model.UpdateItemResult;
import com.amazonaws.services.dynamodbv2.model.WriteRequest;
import com.amazonaws.services.s3.model.Region;
import com.amazonaws.util.VersionInfoUtils;
import com.amazonaws.logging.Log;
import com.amazonaws.logging.LogFactory;
import org.json.JSONObject;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import java.util.Set;
import java.util.UUID;
/**
* Object mapper for domain-object interaction with DynamoDB.
*
* To use, define a domain class that represents an item in a DynamoDB table and
* annotate it with the annotations found in the
* com.amazonaws.mobileconnectors.dynamodbv2.dynamodbmapper package. In order to
* allow the mapper to correctly persist the data, each modeled property in the
* domain class should be accessible via getter and setter methods, and each
* property annotation should be either applied to the getter method or the
* class field. A minimal example using getter annotations:
*
*
* @DynamoDBTable(tableName = "TestTable")
* public class TestClass {
*
* private Long key;
* private double rangeKey;
* private Long version;
*
* private Set<Integer> integerSetAttribute;
*
* @DynamoDBHashKey
* public Long getKey() {
* return key;
* }
*
* public void setKey(Long key) {
* this.key = key;
* }
*
* @DynamoDBRangeKey
* public double getRangeKey() {
* return rangeKey;
* }
*
* public void setRangeKey(double rangeKey) {
* this.rangeKey = rangeKey;
* }
*
* @DynamoDBAttribute(attributeName = "integerSetAttribute")
* public Set<Integer> getIntegerAttribute() {
* return integerSetAttribute;
* }
*
* public void setIntegerAttribute(Set<Integer> integerAttribute) {
* this.integerSetAttribute = integerAttribute;
* }
*
* @DynamoDBVersionAttribute
* public Long getVersion() {
* return version;
* }
*
* public void setVersion(Long version) {
* this.version = version;
* }
* }
*
*
* Save instances of annotated classes to DynamoDB, retrieve them, and delete
* them using the {@link DynamoDBMapper} class, as in the following example.
*
*
* When using the save, load, and delete methods, {@link DynamoDBMapper} will
* throw {@link DynamoDBMappingException}s to indicate that domain classes are
* incorrectly annotated or otherwise incompatible with this class. Service
* exceptions will always be propagated as {@link AmazonClientException}, and
* DynamoDB-specific subclasses such as {@link ConditionalCheckFailedException}
* will be used when possible.
*
* This class is thread-safe and can be shared between threads. It's also very
* lightweight, so it doesn't need to be.
*
* @see DynamoDBTable
* @see DynamoDBHashKey
* @see DynamoDBRangeKey
* @see DynamoDBAutoGeneratedKey
* @see DynamoDBAttribute
* @see DynamoDBVersionAttribute
* @see DynamoDBIgnore
* @see DynamoDBMarshalling
* @see DynamoDBMapperConfig
*/
@SuppressWarnings("checkstyle:hiddenfield")
public class DynamoDBMapper {
private final S3ClientCache s3cc;
private final AmazonDynamoDB db;
private final DynamoDBMapperConfig config;
private final DynamoDBReflector reflector = new DynamoDBReflector();
private final DynamoDBTableSchemaParser schemaParser = new DynamoDBTableSchemaParser();
private final VersionIncrementor incrementor = new VersionIncrementor();
private final AttributeTransformer transformer;
/** The max back off time for batch write */
static final long MAX_BACKOFF_IN_MILLISECONDS = 1000 * 3;
private static final long THREAD_SLEEP_TWO_SECONDS = 1000 * 2;
/** The max number of items allowed in a BatchWrite request */
static final int MAX_ITEMS_PER_BATCH = 25;
private static final int MAX_BATCH_GET_COUNT = 100;
/**
* This retry count is applicable only when every batch get item request
* results in no data retrieved from server and the un processed keys is
* same as request items
*/
static final int BATCH_GET_MAX_RETRY_COUNT_ALL_KEYS = 5;
private static final int EXPONENTIAL_BACKOFF_OFFSET = 500;
private static final int EXPONENTIAL_BACKOFF_RANDOMIZATION_OFFSET = 100;
/**
* User agent for requests made using the {@link DynamoDBMapper}.
*/
private static final String USER_AGENT =
DynamoDBMapper.class.getName() + "/" + VersionInfoUtils.getVersion();
private static final String USER_AGENT_BATCH_OPERATION =
DynamoDBMapper.class.getName() + "_batch_operation/" + VersionInfoUtils.getVersion();
private static String userAgentFromConfig = "";
private static void setUserAgentFromConfig(String userAgent) {
synchronized (DynamoDBMapper.userAgentFromConfig) {
DynamoDBMapper.userAgentFromConfig = userAgent;
}
}
private static String getUserAgentFromConfig() {
synchronized (DynamoDBMapper.userAgentFromConfig) {
if (DynamoDBMapper.userAgentFromConfig == null
|| DynamoDBMapper.userAgentFromConfig.trim().isEmpty()) {
return "";
}
return DynamoDBMapper.userAgentFromConfig.trim() + "/";
}
}
private static final String NO_RANGE_KEY = new String();
private static final Log log = LogFactory.getLog(DynamoDBMapper.class);
/**
* Builder class for DynamoDBMapper
*/
public static class Builder {
private AmazonDynamoDB dynamoDB;
private DynamoDBMapperConfig config;
private AttributeTransformer transformer;
private AWSCredentialsProvider s3CredentialProvider;
private AWSConfiguration awsConfig;
protected Builder() { }
/**
*
* @param dynamoDBClient The service object to use for all service calls
* @return builder
*/
public Builder dynamoDBClient(AmazonDynamoDB dynamoDBClient) {
this.dynamoDB = dynamoDBClient;
return this;
}
/**
* The configuration to use for all service calls. It can be overridden
* on a per-operation basis. If no configuration is provided,
* {@link DynamoDBMapperConfig#DEFAULT} will be used,
*
* @param dynamoConfig config
* @return builder
* @see DynamoDBMapperConfig#DEFAULT
*/
public Builder dynamoDBMapperConfig(DynamoDBMapperConfig dynamoConfig) {
this.config = dynamoConfig;
return this;
}
/**
*
* @param attributeTransformer The custom attribute transformer to invoke when
* serializing or deserializing an object.
* @return builder
*/
public Builder attributeTransformer(AttributeTransformer attributeTransformer) {
this.transformer = attributeTransformer;
return this;
}
/**
*
* @param s3CredentialsProvider The credentials provider for accessing S3.
* Relevant only if {@link S3Link} is involved.
* @return builder
*/
public Builder awsCredentialsProviderForS3(AWSCredentialsProvider s3CredentialsProvider) {
this.s3CredentialProvider = s3CredentialsProvider;
return this;
}
/**
* The region of the AmazonDynamoDB object will be set to
* the region found in the AWSConfiguration.
*
* Example awsconfiguration.json
* {
* "DynamoDBObjectMapper": {
* "Default": {
* "Region": "us-east-1"
* }
* }
* }
* @param awsConfig the config
* @return builder
*/
public Builder awsConfiguration(AWSConfiguration awsConfig) {
this.awsConfig = awsConfig;
return this;
}
/**
*
* @return the constructed DynamoDBMapper
*/
public DynamoDBMapper build() {
if (this.dynamoDB == null) {
throw new IllegalArgumentException("AmazonDynamoDB client is required please set using .dynamoDBClient(yourClient)");
}
if (this.awsConfig != null) {
try {
final JSONObject ddbConfig = awsConfig.optJsonObject("DynamoDBObjectMapper");
final String regionString = ddbConfig.getString("Region");
dynamoDB.setRegion(com.amazonaws.regions.Region.getRegion(com.amazonaws.regions.Regions.fromName(regionString)));
DynamoDBMapper.setUserAgentFromConfig(awsConfig.getUserAgent());
} catch (Exception e) {
throw new IllegalArgumentException("Failed to read Region from AWSConfiguration please check your setup or awsconfiguration.json file", e);
}
}
return new DynamoDBMapper(
this.dynamoDB,
this.config == null ? DynamoDBMapperConfig.DEFAULT : this.config,
this.transformer,
this.s3CredentialProvider,
this.awsConfig);
}
}
/**
* Minimum calls required.
* DynamoDBMapper.builder().dynamoDBClient(client).build()
*
* @return The builder object to construct a DynamoDBMapper.
*/
public static Builder builder() {
return new Builder();
}
private DynamoDBMapper(
final AmazonDynamoDB dynamoDB,
final DynamoDBMapperConfig config,
final AttributeTransformer transformer,
final AWSCredentialsProvider s3CredentialsProvider,
final AWSConfiguration awsConfig) {
this.db = dynamoDB;
this.config = config;
this.transformer = transformer;
if (s3CredentialsProvider == null) {
this.s3cc = null;
} else {
this.s3cc = new S3ClientCache(s3CredentialsProvider);
}
}
/**
* Constructs a new mapper with the service object given, using the default
* configuration.
*
* @param dynamoDB The service object to use for all service calls.
* @see DynamoDBMapperConfig#DEFAULT
* @deprecated Please use DynamoDBMapper.builder()
* .dynamoDBClient(dynamoDB)
* .build();
*/
public DynamoDBMapper(final AmazonDynamoDB dynamoDB) {
this(dynamoDB, DynamoDBMapperConfig.DEFAULT, null, null);
}
/**
* Constructs a new mapper with the service object and configuration given.
*
* @param dynamoDB The service object to use for all service calls.
* @param config The default configuration to use for all service calls. It
* can be overridden on a per-operation basis.
* @deprecated Please use
* DynamoDBMapper.builder()
* .dynamoDBClient(dynamoDB)
* .dynamoDBMapperConfig(config)
* .build();
*/
public DynamoDBMapper(
final AmazonDynamoDB dynamoDB,
final DynamoDBMapperConfig config) {
this(dynamoDB, config, null, null);
}
/**
* Constructs a new mapper with the service object and S3 client cache
* given, using the default configuration.
*
* @param ddb The service object to use for all service calls.
* @param s3CredentialProvider The credentials provider for accessing S3.
* Relevant only if {@link S3Link} is involved.
* @see DynamoDBMapperConfig#DEFAULT
* @deprecated Please use DynamoDBMapper.builder()
* .dynamoDBClient(dynamoDB)
* .awsCredentialsProviderForS3(creds)
* .build();
*/
public DynamoDBMapper(
final AmazonDynamoDB ddb,
final AWSCredentialsProvider s3CredentialProvider) {
this(ddb, DynamoDBMapperConfig.DEFAULT, s3CredentialProvider);
}
/**
* Constructs a new mapper with the given service object, configuration, and
* transform hook.
*
* @param dynamoDB the service object to use for all service calls
* @param config the default configuration to use for all service calls. It
* can be overridden on a per-operation basis
* @param transformer The custom attribute transformer to invoke when
* serializing or deserializing an object.
* @deprecated Please use DynamoDBMapper.builder()
* .dynamoDBClient(dynamoDB)
* .dynamoDBMapperConfig(config)
* .attributeTransformer(transformer)
* .build();
*/
public DynamoDBMapper(
final AmazonDynamoDB dynamoDB,
final DynamoDBMapperConfig config,
final AttributeTransformer transformer) {
this(dynamoDB, config, transformer, null);
}
/**
* Constructs a new mapper with the service object, configuration, and S3
* client cache given.
*
* @param dynamoDB The service object to use for all service calls.
* @param config The default configuration to use for all service calls. It
* can be overridden on a per-operation basis.
* @param s3CredentialProvider The credentials provider for accessing S3.
* Relevant only if {@link S3Link} is involved.
* @deprecated Please use DynamoDBMapper.builder()
* .dynamoDBClient(dynamoDB)
* .dynamoDBMapperConfig(config)
* .awsCredentialsProviderForS3(creds)
* .build();
*/
public DynamoDBMapper(
final AmazonDynamoDB dynamoDB,
final DynamoDBMapperConfig config,
final AWSCredentialsProvider s3CredentialProvider) {
this(dynamoDB, config, null, validate(s3CredentialProvider));
}
/**
* Throws an exception if the given credentials provider is {@code null}.
*/
private static AWSCredentialsProvider validate(
final AWSCredentialsProvider provider) {
if (provider == null) {
throw new IllegalArgumentException(
"s3 credentials provider must not be null");
}
return provider;
}
/**
* Constructor with all parameters.
*
* @param dynamoDB The service object to use for all service calls.
* @param config The default configuration to use for all service calls. It
* can be overridden on a per-operation basis.
* @param transformer The custom attribute transformer to invoke when
* serializing or deserializing an object.
* @param s3CredentialsProvider The credentials provider for accessing S3.
* Relevant only if {@link S3Link} is involved.
* @deprecated Please use DynamoDBMapper.builder()
* .dynamoDBClient(dynamoDB)
* .dynamoDBMapperConfig(config)
* .attributeTransformer(transformer)
* .awsCredentialsProviderForS3(creds)
* .build();
*/
public DynamoDBMapper(
final AmazonDynamoDB dynamoDB,
final DynamoDBMapperConfig config,
final AttributeTransformer transformer,
final AWSCredentialsProvider s3CredentialsProvider) {
this.db = dynamoDB;
this.config = config;
this.transformer = transformer;
if (s3CredentialsProvider == null) {
this.s3cc = null;
} else {
this.s3cc = new S3ClientCache(s3CredentialsProvider);
}
}
/**
* Loads an object with the hash key given and a configuration override.
* This configuration overrides the default provided at object construction.
*
* @param the class type
* @param clazz the class
* @param hashKey the hashkey object
* @param config the {@link DynamoDBMapperConfig}
* @see DynamoDBMapper#load(Class, Object, Object, DynamoDBMapperConfig)
* @return instance of clazz.
*/
@SuppressWarnings("checkstyle:hiddenfield")
public T load(Class clazz, Object hashKey, DynamoDBMapperConfig config) {
return load(clazz, hashKey, null, config);
}
/**
* Loads an object with the hash key given, using the default configuration.
*
* @param the class type
* @param clazz the class
* @param hashKey the hashkey object
* @see DynamoDBMapper#load(Class, Object, Object, DynamoDBMapperConfig)
* @return instance of clazz.
*/
public T load(Class clazz, Object hashKey) {
return load(clazz, hashKey, null, config);
}
/**
* Loads an object with a hash and range key, using the default
* configuration.
*
* @param clazz the class to type the obect to.
* @param hashKey the hash key
* @param rangeKey the range key
* @param the type of the class.
* @see DynamoDBMapper#load(Class, Object, Object, DynamoDBMapperConfig)
* @return an object of type T
*/
public T load(Class clazz, Object hashKey, Object rangeKey) {
return load(clazz, hashKey, rangeKey, config);
}
/**
* Returns an object whose keys match those of the prototype key object
* given, or null if no such item exists.
*
* @param keyObject An object of the class to load with the keys values to
* match.
* @param the type of class.
* @see DynamoDBMapper#load(Object, DynamoDBMapperConfig)
* @return an object of type T
*/
public T load(T keyObject) {
return load(keyObject, this.config);
}
/**
* Returns an object whose keys match those of the prototype key object
* given, or null if no such item exists.
*
* @param keyObject An object of the class to load with the keys values to
* match.
* @param config Configuration for the service call to retrieve the object
* from DynamoDB. This configuration overrides the default given
* at construction.
* @param the type of class.
* @return an object of type T
*/
public T load(T keyObject, DynamoDBMapperConfig config) {
@SuppressWarnings("unchecked")
final Class clazz = (Class) keyObject.getClass();
config = mergeConfig(config);
final ItemConverter converter = getConverter(config);
final String tableName = getTableName(clazz, keyObject, config);
final GetItemRequest rq = new GetItemRequest()
.withRequestMetricCollector(config.getRequestMetricCollector());
final Map key = getKey(converter, keyObject, clazz);
rq.setKey(key);
rq.setTableName(tableName);
rq.setConsistentRead(config.getConsistentReads() == ConsistentReads.CONSISTENT);
final GetItemResult item = db.getItem(applyUserAgent(rq));
final Map itemAttributes = item.getItem();
if (itemAttributes == null) {
return null;
}
final T object = privateMarshallIntoObject(
converter,
toParameters(itemAttributes, clazz, tableName, config));
return object;
}
/**
* Returns a key map for the key object given.
*
* @param keyObject The key object, corresponding to an item in a dynamo
* table.
* @param the type of class.
* @return the key map for a key object given
*/
@SuppressWarnings("unchecked")
private Map getKey(
ItemConverter converter,
T keyObject) {
return getKey(converter, keyObject, (Class) keyObject.getClass());
}
private Map getKey(
ItemConverter converter,
T keyObject,
Class clazz) {
final Map key = new HashMap();
for (final Method keyGetter : reflector.getPrimaryKeyGetters(clazz)) {
final Object getterResult =
ReflectionUtils.safeInvoke(keyGetter, keyObject);
final AttributeValue keyAttributeValue =
converter.convert(keyGetter, getterResult);
if (keyAttributeValue == null) {
throw new DynamoDBMappingException(
"Null key found for " + keyGetter);
}
key.put(reflector.getAttributeName(keyGetter), keyAttributeValue);
}
if (key.isEmpty()) {
throw new DynamoDBMappingException(
"Class must be annotated with " + DynamoDBHashKey.class
+ " and " + DynamoDBRangeKey.class);
}
return key;
}
/**
* Returns an object with the given hash key, or null if no such object
* exists.
*
* @param clazz The class to load, corresponding to a DynamoDB table.
* @param hashKey The key of the object.
* @param rangeKey The range key of the object, or null for tables without a
* range key.
* @param config Configuration for the service call to retrieve the object
* from DynamoDB. This configuration overrides the default given
* at construction.
* @param the type of class.
* @return an object with the given hash key, or null if no such object
* exists.
*/
public T load(Class clazz, Object hashKey, Object rangeKey,
DynamoDBMapperConfig config) {
config = mergeConfig(config);
final T keyObject = createKeyObject(clazz, hashKey, rangeKey);
return load(keyObject, config);
}
/**
* Creates a key prototype object for the class given with the single hash
* and range key given.
*
* @param the type of class.
*/
T createKeyObject(Class clazz, Object hashKey, Object rangeKey) {
T keyObject = null;
try {
keyObject = clazz.newInstance();
} catch (final Exception e) {
throw new DynamoDBMappingException("Failed to instantiate class", e);
}
boolean seenHashKey = false;
boolean seenRangeKey = false;
for (final Method getter : reflector.getPrimaryKeyGetters(clazz)) {
if (ReflectionUtils.getterOrFieldHasAnnotation(getter, DynamoDBHashKey.class)) {
if (seenHashKey) {
throw new DynamoDBMappingException(
"Found more than one method annotated with "
+ DynamoDBHashKey.class
+ " for class "
+ clazz
+ ". Use load(Object) for tables with more than a single hash and range key.");
}
seenHashKey = true;
ReflectionUtils.safeInvoke(reflector.getSetter(getter), keyObject, hashKey);
} else if (ReflectionUtils.getterOrFieldHasAnnotation(getter, DynamoDBRangeKey.class)) {
if (seenRangeKey) {
throw new DynamoDBMappingException(
"Found more than one method annotated with "
+ DynamoDBRangeKey.class
+ " for class "
+ clazz
+ ". Use load(Object) for tables with more than a single hash and range key.");
}
seenRangeKey = true;
ReflectionUtils.safeInvoke(reflector.getSetter(getter), keyObject, rangeKey);
}
}
if (!seenHashKey) {
throw new DynamoDBMappingException("No method annotated with " + DynamoDBHashKey.class
+ " for class "
+ clazz + ".");
} else if (rangeKey != null && !seenRangeKey) {
throw new DynamoDBMappingException("No method annotated with " + DynamoDBRangeKey.class
+ " for class "
+ clazz + ".");
}
return keyObject;
}
/**
* Returns a map of attribute name to EQ condition for the key prototype
* object given. This method considers attributes annotated with either
* {@link DynamoDBHashKey} or {@link DynamoDBIndexHashKey}.
*
* @param obj The prototype object that includes the hash key value.
* @return A map of hash key attribute name to EQ condition for the key
* prototype object, or an empty map if obj is null.
*/
private Map getHashKeyEqualsConditions(
ItemConverter converter,
Object obj) {
final Map conditions = new HashMap();
if (obj == null) {
return conditions;
}
for (final Method getter : reflector.getRelevantGetters(obj.getClass())) {
if (ReflectionUtils.getterOrFieldHasAnnotation(
getter, DynamoDBHashKey.class)
|| ReflectionUtils.getterOrFieldHasAnnotation(
getter, DynamoDBIndexHashKey.class)) {
final Object getterReturnResult =
ReflectionUtils.safeInvoke(getter, obj);
if (getterReturnResult != null) {
conditions.put(
reflector.getAttributeName(getter),
new Condition()
.withComparisonOperator(ComparisonOperator.EQ)
.withAttributeValueList(
converter.convert(getter, getterReturnResult)));
}
}
}
return conditions;
}
/**
* Returns the table name for the class given.
*/
protected final String getTableName(final Class clazz,
final DynamoDBMapperConfig config) {
return internalGetTableName(clazz, null, config);
}
/**
* Returns the table name for the class or object given.
*/
protected final String getTableName(final Class clazz,
final Object object,
final DynamoDBMapperConfig config) {
return internalGetTableName(clazz, object, config);
}
static String internalGetTableName(final Class clazz,
final Object object,
final DynamoDBMapperConfig config) {
// Resolve by object, if possible and desired
final DynamoDBMapperConfig.ObjectTableNameResolver objectResolver = config
.getObjectTableNameResolver();
if (object != null && objectResolver != null) {
return objectResolver.getTableName(object, config);
}
// Resolve by class
DynamoDBMapperConfig.TableNameResolver classResolver = config.getTableNameResolver();
if (classResolver == null) {
classResolver = DynamoDBMapperConfig.DefaultTableNameResolver.INSTANCE;
}
return classResolver.getTableName(clazz, config);
}
/**
* Creates and fills in the attributes on an instance of the class given
* with the attributes given.
*
* This is accomplished by looking for getter methods annotated with an
* appropriate annotation, then looking for matching attribute names in the
* item attribute map.
*
* This method is no longer called by load/scan/query methods. If you are
* overriding this method, please switch to using an AttributeTransformer
*
* @param clazz The class to instantiate and hydrate
* @param itemAttributes The set of item attributes, keyed by attribute
* name.
* @param the type of object.
* @return an object of type T
*/
public T marshallIntoObject(
Class clazz,
Map itemAttributes) {
final ItemConverter converter = getConverter(config);
final String tableName = getTableName(clazz, config);
return privateMarshallIntoObject(
converter,
toParameters(itemAttributes, clazz, tableName, config));
}
/**
* The one true implementation of marshallIntoObject.
*/
private T privateMarshallIntoObject(
ItemConverter converter,
AttributeTransformer.Parameters parameters) {
final Class clazz = parameters.getModelClass();
final Map values = untransformAttributes(parameters);
return converter.unconvert(clazz, values);
}
/**
* Unmarshalls the list of item attributes into objects of type clazz.
*
* This method is no longer called by load/scan/query methods. If you are
* overriding this method, please switch to using an AttributeTransformer
*
* @param clazz the class to marshall into.
* @param itemAttributes the item attributes.
* @param the type of object.
* @return an list of objects of type T
* @see DynamoDBMapper#marshallIntoObject(Class, Map)
*/
public List marshallIntoObjects(Class clazz,
List> itemAttributes) {
final List result = new ArrayList(itemAttributes.size());
for (final Map item : itemAttributes) {
result.add(marshallIntoObject(clazz, item));
}
return result;
}
/**
* A replacement for {@link #marshallIntoObjects(Class, List)} that takes an
* extra set of parameters to be tunneled through to
* {@code privateMarshalIntoObject} (if nothing along the way is
* overridden). It's package-private because some of the Paginated*List
* classes call back into it, but final because no one, even in this
* package, should ever override it.
*/
final List marshallIntoObjects(
final List> parameters) {
final List result = new ArrayList(parameters.size());
ItemConverter converter = null;
if (!parameters.isEmpty()) {
converter = getConverter(parameters.get(0).getMapperConfig());
}
for (final AttributeTransformer.Parameters entry : parameters) {
result.add(privateMarshallIntoObject(converter, entry));
}
return result;
}
/**
* Saves the object given into DynamoDB, using the default configuration.
*
* @param the type of object.
* @param object the object to save.
* @see DynamoDBMapper#save(Object, DynamoDBSaveExpression,
* DynamoDBMapperConfig)
*/
public void save(T object) {
save(object, null, config);
}
/**
* Saves the object given into DynamoDB, using the default configuration and
* the specified saveExpression.
*
* @param object the object to save.
* @param saveExpression the {@link DynamoDBSaveExpression}
* @param the type of object.
* @see DynamoDBMapper#save(Object, DynamoDBSaveExpression,
* DynamoDBMapperConfig)
*/
public void save(T object, DynamoDBSaveExpression saveExpression) {
save(object, saveExpression, config);
}
boolean needAutoGenerateAssignableKey(Class clazz, Object object) {
final Collection keyGetters = reflector.getPrimaryKeyGetters(clazz);
boolean forcePut = false;
/*
* Determine if there are any auto-assigned keys to assign. If so, force
* a put and assign the keys.
*/
boolean hashKeyGetterFound = false;
for (final Method method : keyGetters) {
final Object getterResult = ReflectionUtils.safeInvoke(method, object);
if (getterResult == null && reflector.isAssignableKey(method)) {
forcePut = true;
}
if (ReflectionUtils.getterOrFieldHasAnnotation(method, DynamoDBHashKey.class)) {
hashKeyGetterFound = true;
}
}
if (!hashKeyGetterFound) {
throw new DynamoDBMappingException("No " + DynamoDBHashKey.class
+ " annotation found in class " + clazz);
}
return forcePut;
}
/**
* Saves the object given into DynamoDB, using the specified configuration.
*
* @param object the object to save.
* @param config the {@link DynamoDBMapperConfig}
* @param the type of object.
* @see DynamoDBMapper#save(Object, DynamoDBSaveExpression,
* DynamoDBMapperConfig)
*/
public void save(T object, DynamoDBMapperConfig config) {
save(object, null, config);
}
/**
* Saves an item in DynamoDB. The service method used is determined by the
* {@link DynamoDBMapperConfig#getSaveBehavior()} value, to use either
* {@link AmazonDynamoDB#putItem(PutItemRequest)} or
* {@link AmazonDynamoDB#updateItem(UpdateItemRequest)}:
*
*
UPDATE (default) : UPDATE will not affect unmodeled attributes
* on a save operation and a null value for the modeled attribute will
* remove it from that item in DynamoDB. Because of the limitation of
* updateItem request, the implementation of UPDATE will send a putItem
* request when a key-only object is being saved, and it will send another
* updateItem request if the given key(s) already exists in the table.
*
UPDATE_SKIP_NULL_ATTRIBUTES : Similar to UPDATE except that it
* ignores any null value attribute(s) and will NOT remove them from that
* item in DynamoDB. It also guarantees to send only one single updateItem
* request, no matter the object is key-only or not.
*
CLOBBER : CLOBBER will clear and replace all attributes,
* included unmodeled ones, (delete and recreate) on save. Versioned field
* constraints will also be disregarded.
*
* Any options specified in the saveExpression parameter will be overlaid on
* any constraints due to versioned attributes.
*
* @param object The object to save into DynamoDB
* @param saveExpression The options to apply to this save request
* @param config The configuration to use, which overrides the default
* provided at object construction.
* @param the type of object.
* @see DynamoDBMapperConfig.SaveBehavior
*/
public void save(T object, DynamoDBSaveExpression saveExpression,
final DynamoDBMapperConfig config) {
final DynamoDBMapperConfig finalConfig = mergeConfig(config);
final ItemConverter converter = getConverter(finalConfig);
@SuppressWarnings("unchecked")
final Class clazz = (Class) object.getClass();
final String tableName = getTableName(clazz, object, finalConfig);
/*
* We force a putItem request instead of updateItem request either when
* CLOBBER is configured, or part of the primary key of the object needs
* to be auto-generated.
*/
final boolean forcePut = (finalConfig.getSaveBehavior() == SaveBehavior.CLOBBER)
|| needAutoGenerateAssignableKey(clazz, object);
SaveObjectHandler saveObjectHandler;
if (forcePut) {
saveObjectHandler = this.new SaveObjectHandler(clazz, object,
tableName, finalConfig, converter, saveExpression) {
@Override
protected void onKeyAttributeValue(String attributeName,
AttributeValue keyAttributeValue) {
/* Treat key values as common attribute value updates. */
getAttributeValueUpdates().put(attributeName,
new AttributeValueUpdate().withValue(keyAttributeValue)
.withAction("PUT"));
}
/* Use default implementation of onNonKeyAttribute(...) */
@Override
protected void onNullNonKeyAttribute(String attributeName) {
/*
* When doing a force put, we can safely ignore the
* null-valued attributes.
*/
return;
}
@Override
protected void executeLowLevelRequest() {
/* Send a putItem request */
doPutItem();
}
};
} else {
saveObjectHandler = this.new SaveObjectHandler(clazz, object,
tableName, finalConfig, converter, saveExpression) {
@Override
protected void onKeyAttributeValue(String attributeName,
AttributeValue keyAttributeValue) {
/*
* Put it in the key collection which is later used in the
* updateItem request.
*/
getKeyAttributeValues().put(attributeName, keyAttributeValue);
}
@Override
protected void onNonKeyAttribute(String attributeName,
AttributeValue currentValue) {
/*
* If it's a set attribute and the mapper is configured with
* APPEND_SET, we do an "ADD" update instead of the default
* "PUT".
*/
if (getLocalSaveBehavior() == SaveBehavior.APPEND_SET) {
if (currentValue.getBS() != null
|| currentValue.getNS() != null
|| currentValue.getSS() != null) {
getAttributeValueUpdates().put(
attributeName,
new AttributeValueUpdate().withValue(
currentValue).withAction("ADD"));
return;
}
}
/* Otherwise, we do the default "PUT" update. */
super.onNonKeyAttribute(attributeName, currentValue);
}
@Override
protected void onNullNonKeyAttribute(String attributeName) {
/*
* If UPDATE_SKIP_NULL_ATTRIBUTES or APPEND_SET is
* configured, we don't delete null value attributes.
*/
if (getLocalSaveBehavior() == SaveBehavior.UPDATE_SKIP_NULL_ATTRIBUTES
|| getLocalSaveBehavior() == SaveBehavior.APPEND_SET) {
return;
}
else {
/* Delete attributes that are set as null in the object. */
getAttributeValueUpdates()
.put(attributeName,
new AttributeValueUpdate()
.withAction("DELETE"));
}
}
@Override
protected void executeLowLevelRequest() {
final UpdateItemResult updateItemResult = doUpdateItem();
// The UpdateItem request is specified to return ALL_NEW
// attributes of the affected item. So if the returned
// UpdateItemResult does not include any ReturnedAttributes,
// it indicates the UpdateItem failed silently (e.g. the
// key-only-put nightmare -
// https://forums.aws.amazon.com/thread.jspa?threadID=86798&tstart=25),
// in which case we should re-send a PutItem
// request instead.
if (updateItemResult.getAttributes() == null
|| updateItemResult.getAttributes().isEmpty()) {
// Before we proceed with PutItem, we need to put all
// the key attributes (prepared for the
// UpdateItemRequest) into the AttributeValueUpdates
// collection.
for (final String keyAttributeName : getKeyAttributeValues().keySet()) {
getAttributeValueUpdates().put(
keyAttributeName,
new AttributeValueUpdate()
.withValue(
getKeyAttributeValues().get(keyAttributeName))
.withAction("PUT"));
}
doPutItem();
}
}
};
}
saveObjectHandler.execute();
}
/**
* The handler for saving object using DynamoDBMapper. Caller should
* implement the abstract methods to provide the expected behavior on each
* scenario, and this handler will take care of all the other basic workflow
* and common operations.
*/
protected abstract class SaveObjectHandler {
protected final Object object;
protected final Class clazz;
private final String tableName;
private final DynamoDBMapperConfig saveConfig;
private final ItemConverter converter;
private final Map key;
private final Map updateValues;
/**
* Any expected value conditions specified by the implementation of
* DynamoDBMapper, e.g. value assertions on versioned attributes.
*/
private final Map internalExpectedValueAssertions;
/**
* Additional expected value conditions specified by the user.
*/
protected final Map userProvidedExpectedValueConditions;
/**
* Condition operator on the additional expected value conditions
* specified by the user.
*/
protected final String userProvidedConditionOperator;
private final List inMemoryUpdates;
/**
* Constructs a handler for saving the specified model object.
*
* @param object The model object to be saved.
* @param clazz The domain class of the object.
* @param tableName The table name.
* @param saveConifg The mapper configuration used for this save.
* @param saveExpression The save expression, including the
* user-provided conditions and an optional logic operator.
*/
public SaveObjectHandler(
Class clazz,
Object object,
String tableName,
DynamoDBMapperConfig saveConfig,
ItemConverter converter,
DynamoDBSaveExpression saveExpression) {
this.clazz = clazz;
this.object = object;
this.tableName = tableName;
this.saveConfig = saveConfig;
this.converter = converter;
if (saveExpression != null) {
userProvidedExpectedValueConditions = saveExpression
.getExpected();
userProvidedConditionOperator = saveExpression
.getConditionalOperator();
} else {
userProvidedExpectedValueConditions = null;
userProvidedConditionOperator = null;
}
updateValues = new HashMap();
internalExpectedValueAssertions = new HashMap();
inMemoryUpdates = new LinkedList();
key = new HashMap();
}
/**
* The general workflow of a save operation.
*/
public void execute() {
final Collection keyGetters = reflector.getPrimaryKeyGetters(clazz);
/*
* First handle keys
*/
for (final Method method : keyGetters) {
final Object getterResult = ReflectionUtils.safeInvoke(method, object);
final String attributeName = reflector.getAttributeName(method);
if (getterResult == null && reflector.isAssignableKey(method)) {
onAutoGenerateAssignableKey(method, attributeName);
}
else {
final AttributeValue newAttributeValue = converter.convert(method, getterResult);
if (newAttributeValue == null) {
throw new DynamoDBMappingException(
"Null or empty value for key: " + method);
}
if (newAttributeValue.getS() == null
&& newAttributeValue.getN() == null
&& newAttributeValue.getB() == null) {
throw new DynamoDBMappingException(
"Keys must be scalar values (String, Number, "
+ "or Binary). Got " + newAttributeValue
+ " for key " + method);
}
onKeyAttributeValue(attributeName, newAttributeValue);
}
}
/*
* Next construct an update for every non-key property
*/
for (final Method method : reflector.getRelevantGetters(clazz)) {
// Skip any key methods, since they are handled separately
if (keyGetters.contains(method)) {
continue;
}
final Object getterResult = ReflectionUtils.safeInvoke(method, object);
final String attributeName = reflector.getAttributeName(method);
/*
* If this is a versioned field, update it
*/
if (reflector.isVersionAttributeGetter(method)) {
onVersionAttribute(method, getterResult, attributeName);
}
/*
* Otherwise apply the update value for this attribute.
*/
else {
final AttributeValue currentValue = converter.convert(method, getterResult);
if (currentValue != null) {
onNonKeyAttribute(attributeName, currentValue);
} else {
onNullNonKeyAttribute(attributeName);
}
}
}
/*
* Execute the implementation of the low level request.
*/
executeLowLevelRequest();
/*
* Finally, after the service call has succeeded, update the
* in-memory object with new field values as appropriate. This
* currently takes into account of auto-generated keys and versioned
* attributes.
*/
for (final ValueUpdate update : inMemoryUpdates) {
update.apply();
}
}
/**
* Implement this method to do the necessary operations when a key
* attribute is set with some value.
*
* @param attributeName The name of the key attribute.
* @param keyAttributeValue The AttributeValue of the key attribute as
* specified in the object.
*/
protected abstract void onKeyAttributeValue(String attributeName,
AttributeValue keyAttributeValue);
/**
* Implement this method for necessary operations when a non-key
* attribute is set a non-null value in the object. The default
* implementation simply adds a "PUT" update for the given attribute.
*
* @param attributeName The name of the non-key attribute.
* @param currentValue The updated value of the given attribute.
*/
protected void onNonKeyAttribute(String attributeName, AttributeValue currentValue) {
updateValues.put(attributeName, new AttributeValueUpdate()
.withValue(currentValue).withAction("PUT"));
}
/**
* Implement this method for necessary operations when a non-key
* attribute is set null in the object.
*
* @param attributeName The name of the non-key attribute.
*/
protected abstract void onNullNonKeyAttribute(String attributeName);
/**
* Implement this method to send the low-level request that is necessary
* to complete the save operation.
*/
protected abstract void executeLowLevelRequest();
/** Get the SaveBehavior used locally for this save operation. **/
protected SaveBehavior getLocalSaveBehavior() {
return saveConfig.getSaveBehavior();
}
/** Get the table name **/
protected String getTableName() {
return tableName;
}
/** Get the map of all the specified key of the saved object. **/
protected Map getKeyAttributeValues() {
return key;
}
/** Get the map of AttributeValueUpdate on each modeled attribute. **/
protected Map getAttributeValueUpdates() {
return updateValues;
}
/**
* Merge and return all the expected value conditions (either
* user-specified or imposed by the internal implementation of
* DynamoDBMapper) for this save operation.
*/
protected Map mergeExpectedAttributeValueConditions() {
return DynamoDBMapper.mergeExpectedAttributeValueConditions(
internalExpectedValueAssertions,
userProvidedExpectedValueConditions,
userProvidedConditionOperator);
}
/** Get the list of all the necessary in-memory update on the object. **/
protected List getInMemoryUpdates() {
return inMemoryUpdates;
}
/**
* Save the item using a UpdateItem request. The handler will call this
* method if
*
*
CLOBBER configuration is not being used;
*
AND the item does not contain auto-generated key value;
*
*
* The ReturnedValues parameter for the UpdateItem request is set as
* ALL_NEW, which means the service should return all of the attributes
* of the new version of the item after the update. The handler will use
* the returned attributes to detect silent failure on the server-side.
*/
protected UpdateItemResult doUpdateItem() {
final UpdateItemRequest req = new UpdateItemRequest()
.withTableName(getTableName())
.withKey(getKeyAttributeValues())
.withAttributeUpdates(
transformAttributeUpdates(
this.clazz,
getTableName(),
getKeyAttributeValues(),
getAttributeValueUpdates(),
saveConfig))
.withExpected(mergeExpectedAttributeValueConditions())
.withConditionalOperator(userProvidedConditionOperator)
.withReturnValues(ReturnValue.ALL_NEW)
.withRequestMetricCollector(saveConfig.getRequestMetricCollector());
return db.updateItem(applyUserAgent(req));
}
/**
* Save the item using a PutItem request. The handler will call this
* method if
*
*
CLOBBER configuration is being used;
*
OR the item contains auto-generated key value;
*
OR an UpdateItem request has silently failed (200 response with
* no affected attribute), which indicates the key-only-put scenario
* that we used to handle by the keyOnlyPut(...) hack.
*
*/
protected PutItemResult doPutItem() {
Map attributeValues = convertToItem(getAttributeValueUpdates());
attributeValues = transformAttributes(
toParameters(attributeValues,
this.clazz,
getTableName(),
saveConfig));
final PutItemRequest req = new PutItemRequest()
.withTableName(getTableName())
.withItem(attributeValues)
.withExpected(mergeExpectedAttributeValueConditions())
.withConditionalOperator(userProvidedConditionOperator)
.withRequestMetricCollector(saveConfig.getRequestMetricCollector());
return db.putItem(applyUserAgent(req));
}
private void onAutoGenerateAssignableKey(Method method, String attributeName) {
final AttributeValue newVersionValue = getAutoGeneratedKeyAttributeValue(converter, method);
updateValues.put(attributeName,
new AttributeValueUpdate().withAction("PUT").withValue(newVersionValue));
inMemoryUpdates.add(new ValueUpdate(method, newVersionValue, object, converter));
if (getLocalSaveBehavior() != SaveBehavior.CLOBBER
&& !internalExpectedValueAssertions.containsKey(attributeName)) {
// Add an expect clause to make sure that the item
// doesn't already exist, since it's supposed to be new
final ExpectedAttributeValue expected = new ExpectedAttributeValue();
expected.setExists(false);
internalExpectedValueAssertions.put(attributeName, expected);
}
}
private void onVersionAttribute(Method method, Object getterResult,
String attributeName) {
if (getLocalSaveBehavior() != SaveBehavior.CLOBBER
&& !internalExpectedValueAssertions.containsKey(attributeName)) {
// First establish the expected (current) value for the
// update call
final ExpectedAttributeValue expected = new ExpectedAttributeValue();
// For new objects, insist that the value doesn't exist.
// For existing ones, insist it has the old value.
final AttributeValue currentValue = converter.convert(method, getterResult);
expected.setExists(currentValue != null);
if (currentValue != null) {
expected.setValue(currentValue);
}
internalExpectedValueAssertions.put(attributeName, expected);
}
final Object newVersion = incrementor.increment(method, getterResult);
final AttributeValue newVersionValue = converter.convert(method, newVersion);
updateValues.put(attributeName, new AttributeValueUpdate()
.withAction("PUT")
.withValue(newVersionValue));
inMemoryUpdates.add(new ValueUpdate(method, newVersionValue, object, converter));
}
}
/**
* Deletes the given object from its DynamoDB table using the default
* configuration.
*
* @param object the object to delete.
*/
public void delete(Object object) {
delete(object, null, this.config);
}
/**
* Deletes the given object from its DynamoDB table using the specified
* deleteExpression and default configuration.
*
* @param object the object to delete.
* @param deleteExpression the {@link DynamoDBDeleteExpression}
*/
public void delete(Object object, DynamoDBDeleteExpression deleteExpression) {
delete(object, deleteExpression, this.config);
}
/**
* Deletes the given object from its DynamoDB table using the specified
* configuration.
*
* @param object the object to delete.
* @param config the {@link DynamoDBMapperConfig}
*/
public void delete(Object object, DynamoDBMapperConfig config) {
delete(object, null, config);
}
/**
* Deletes the given object from its DynamoDB table using the provided
* deleteExpression and provided configuration. Any options specified in the
* deleteExpression parameter will be overlaid on any constraints due to
* versioned attributes.
*
* @param deleteExpression The options to apply to this delete request
* @param config Config override object. If {@link SaveBehavior#CLOBBER} is
* supplied, version fields will not be considered when deleting
* the object.
* @param object the object to delete.
* @param the type of the object.
*/
public void delete(T object, DynamoDBDeleteExpression deleteExpression,
DynamoDBMapperConfig config) {
config = mergeConfig(config);
final ItemConverter converter = getConverter(config);
@SuppressWarnings("unchecked")
final Class clazz = (Class) object.getClass();
final String tableName = getTableName(clazz, object, config);
final Map key = getKey(converter, object, clazz);
/*
* If there is a version field, make sure we assert its value. If the
* version field is null (only should happen in unusual circumstances),
* pretend it doesn't have a version field after all.
*/
final Map internalAssertions = new HashMap();
if (config.getSaveBehavior() != SaveBehavior.CLOBBER) {
for (final Method method : reflector.getRelevantGetters(clazz)) {
if (reflector.isVersionAttributeGetter(method)) {
final Object getterResult = ReflectionUtils.safeInvoke(method, object);
final String attributeName = reflector.getAttributeName(method);
final ExpectedAttributeValue expected = new ExpectedAttributeValue();
final AttributeValue currentValue = converter.convert(method, getterResult);
expected.setExists(currentValue != null);
if (currentValue != null) {
expected.setValue(currentValue);
}
internalAssertions.put(attributeName, expected);
break;
}
}
}
DeleteItemRequest req = new DeleteItemRequest().withKey(key)
.withTableName(tableName).withExpected(internalAssertions)
.withRequestMetricCollector(config.getRequestMetricCollector());
if (deleteExpression != null) {
final String conditionalExpression = deleteExpression.getConditionExpression();
if (conditionalExpression != null) {
if (internalAssertions != null && !internalAssertions.isEmpty()) {
throw new AmazonClientException(
"Condition Expressions cannot be used if a versioned attribute is present");
}
req = req
.withConditionExpression(conditionalExpression)
.withExpressionAttributeNames(
deleteExpression.getExpressionAttributeNames())
.withExpressionAttributeValues(
deleteExpression.getExpressionAttributeValues());
}
req = req.withExpected(
mergeExpectedAttributeValueConditions(internalAssertions,
deleteExpression.getExpected(),
deleteExpression.getConditionalOperator()))
.withConditionalOperator(
deleteExpression.getConditionalOperator());
}
db.deleteItem(applyUserAgent(req));
}
/**
* Deletes the objects given using one or more calls to the
* {@link AmazonDynamoDB#batchWriteItem(BatchWriteItemRequest)} API. No
* version checks are performed, as required by the API.
*
* @param objectsToDelete the objects to delete.
* @see DynamoDBMapper#batchWrite(List, List, DynamoDBMapperConfig)
* @return list of failed batches/
*/
public List batchDelete(List objectsToDelete) {
return batchWrite(Collections.emptyList(), objectsToDelete, this.config);
}
/**
* Deletes the objects given using one or more calls to the
* {@link AmazonDynamoDB#batchWriteItem(BatchWriteItemRequest)} API. No
* version checks are performed, as required by the API.
*
* @param objectsToDelete list of objects to delete.
* @return list of failed batches.
* @see DynamoDBMapper#batchWrite(List, List, DynamoDBMapperConfig)
*/
public List batchDelete(Object... objectsToDelete) {
return batchWrite(Collections.emptyList(), Arrays.asList(objectsToDelete), this.config);
}
/**
* Saves the objects given using one or more calls to the
* {@link AmazonDynamoDB#batchWriteItem(BatchWriteItemRequest)} API. No
* version checks are performed, as required by the API.
*
* This method ignores any SaveBehavior set on the mapper, and always
* behaves as if SaveBehavior.CLOBBER was specified, as the
* AmazonDynamoDB.batchWriteItem() request does not support updating
* existing items.
*
* This method fails to save the batch if the size of an individual object
* in the batch exceeds 400 KB. For more information on batch restrictions
* see, http://docs.aws.amazon
* .com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html
*
*
* @param objectsToSave list of objects to save.
* @return list of objects that failed to save.
* @see DynamoDBMapper#batchWrite(List, List, DynamoDBMapperConfig)
*/
public List batchSave(List objectsToSave) {
return batchWrite(objectsToSave, Collections.emptyList(), this.config);
}
/**
* Saves the objects given using one or more calls to the
* {@link AmazonDynamoDB#batchWriteItem(BatchWriteItemRequest)} API. No
* version checks are performed, as required by the API.
*
* This method ignores any SaveBehavior set on the mapper, and always
* behaves as if SaveBehavior.CLOBBER was specified, as the
* AmazonDynamoDB.batchWriteItem() request does not support updating
* existing items. *
*
* This method fails to save the batch if the size of an individual object
* in the batch exceeds 400 KB. For more information on batch restrictions
* see, http://docs.aws.amazon
* .com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html
*
*
* @param objectsToSave list of objects to save.
* @return list of objects that failed to save.
* @see DynamoDBMapper#batchWrite(List, List, DynamoDBMapperConfig)
*/
public List batchSave(Object... objectsToSave) {
return batchWrite(Arrays.asList(objectsToSave), Collections.emptyList(), this.config);
}
/**
* Saves and deletes the objects given using one or more calls to the
* {@link AmazonDynamoDB#batchWriteItem(BatchWriteItemRequest)} API. No
* version checks are performed, as required by the API.
*
* This method ignores any SaveBehavior set on the mapper, and always
* behaves as if SaveBehavior.CLOBBER was specified, as the
* AmazonDynamoDB.batchWriteItem() request does not support updating
* existing items.
*
* This method fails to save the batch if the size of an individual object
* in the batch exceeds 400 KB. For more information on batch restrictions
* see, http://docs.aws.amazon
* .com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html
*
*
* @param objectsToWrite list of objects to write.
** @param objectsToDelete list of objects to delete.
* @return list of objects that failed the opeartion.
* @see DynamoDBMapper#batchWrite(List, List, DynamoDBMapperConfig)
*/
public List batchWrite(List objectsToWrite,
List objectsToDelete) {
return batchWrite(objectsToWrite, objectsToDelete, this.config);
}
/**
* Saves and deletes the objects given using one or more calls to the
* {@link AmazonDynamoDB#batchWriteItem(BatchWriteItemRequest)} API.
*
* This method fails to save the batch if the size of an individual object
* in the batch exceeds 400 KB. For more information on batch restrictions
* see, http://docs.aws.amazon
* .com/amazondynamodb/latest/APIReference/API_BatchWriteItem.html
*
*
* @param objectsToWrite A list of objects to save to DynamoDB. No
* version checks are performed, as required by the
* {@link AmazonDynamoDB#batchWriteItem(BatchWriteItemRequest)}
* API.
* @param objectsToDelete A list of objects to delete from DynamoDB. No
* version checks are performed, as required by the
* {@link AmazonDynamoDB#batchWriteItem(BatchWriteItemRequest)}
* API.
* @param config Only {@link DynamoDBMapperConfig#getTableNameOverride()} is
* considered; if specified, all objects in the two parameter
* lists will be considered to belong to the given table
* override. In particular, this method always acts as if
* SaveBehavior.CLOBBER was specified regardless of the value
* of the config parameter.
* @return A list of failed batches which includes the unprocessed items and
* the exceptions causing the failure.
*/
public List batchWrite(List objectsToWrite,
List objectsToDelete, DynamoDBMapperConfig config) {
config = mergeConfig(config);
final List totalFailedBatches = new LinkedList();
final HashMap> requestItems = new HashMap>();
final ItemConverter converter = getConverter(config);
final List inMemoryUpdates = new LinkedList();
for (final Object toWrite : objectsToWrite) {
final Class clazz = toWrite.getClass();
final String tableName = getTableName(clazz, toWrite, config);
final Map attributeValues = new HashMap();
// Look at every getter and construct a value object for it
for (final Method method : reflector.getRelevantGetters(clazz)) {
final Object getterResult =
ReflectionUtils.safeInvoke(method, toWrite);
final String attributeName = reflector.getAttributeName(method);
AttributeValue currentValue = null;
if (getterResult == null && reflector.isAssignableKey(method)) {
currentValue = getAutoGeneratedKeyAttributeValue(converter, method);
inMemoryUpdates.add(new ValueUpdate(method, currentValue, toWrite, converter));
} else {
currentValue = converter.convert(method, getterResult);
}
if (currentValue != null) {
attributeValues.put(attributeName, currentValue);
}
}
if (!requestItems.containsKey(tableName)) {
requestItems.put(tableName, new LinkedList());
}
final AttributeTransformer.Parameters parameters =
toParameters(attributeValues, clazz, tableName, config);
requestItems.get(tableName).add(
new WriteRequest().withPutRequest(
new PutRequest().withItem(
transformAttributes(parameters))));
}
for (final Object toDelete : objectsToDelete) {
final Class clazz = toDelete.getClass();
final String tableName = getTableName(clazz, toDelete, config);
final Map key = getKey(converter, toDelete);
if (!requestItems.containsKey(tableName)) {
requestItems.put(tableName, new LinkedList());
}
requestItems.get(tableName).add(
new WriteRequest().withDeleteRequest(new DeleteRequest().withKey(key)));
}
// Break into chunks of 25 items and make service requests to DynamoDB
while (!requestItems.isEmpty()) {
final HashMap> batch =
new HashMap>();
int i = 0;
final Iterator>> tableIter = requestItems.entrySet()
.iterator();
while (tableIter.hasNext() && i < MAX_ITEMS_PER_BATCH) {
final Entry> tableRequest = tableIter.next();
batch.put(tableRequest.getKey(), new LinkedList());
final Iterator writeRequestIter = tableRequest.getValue().iterator();
while (writeRequestIter.hasNext() && i++ < MAX_ITEMS_PER_BATCH) {
final WriteRequest writeRequest = writeRequestIter.next();
batch.get(tableRequest.getKey()).add(writeRequest);
writeRequestIter.remove();
}
// If we've processed all the write requests for this table,
// remove it from the parent iterator.
if (!writeRequestIter.hasNext()) {
tableIter.remove();
}
}
final List failedBatches = writeOneBatch(batch);
if (failedBatches != null) {
totalFailedBatches.addAll(failedBatches);
// If contains throttling exception, we do a backoff
if (containsThrottlingException(failedBatches)) {
try {
Thread.sleep(THREAD_SLEEP_TWO_SECONDS);
} catch (final InterruptedException e) {
Thread.currentThread().interrupt();
throw new AmazonClientException(e.getMessage(), e);
}
}
}
}
// Once the entire batch is processed, update assigned keys in memory
for (final ValueUpdate update : inMemoryUpdates) {
update.apply();
}
return totalFailedBatches;
}
/**
* Process one batch of requests(max 25). It will divide the batch if
* receives request too large exception(the total size of the request is
* beyond 1M).
*/
List writeOneBatch(Map> batch) {
final List failedBatches = new LinkedList();
final Map> firstHalfBatch = new HashMap>();
final Map> secondHalfBatch = new HashMap>();
final FailedBatch failedBatch = callUntilCompletion(batch);
if (failedBatch != null) {
// If the exception is request entity too large, we divide the batch
// into smaller parts.
if (failedBatch.getException() instanceof AmazonServiceException
&& RetryUtils
.isRequestEntityTooLargeException((AmazonServiceException) failedBatch
.getException())) {
// If only one item left, the item size must beyond 64k, which
// exceedes the limit.
if (computeFailedBatchSize(failedBatch) == 1) {
failedBatches.add(failedBatch);
} else {
divideBatch(batch, firstHalfBatch, secondHalfBatch);
failedBatches.addAll(writeOneBatch(firstHalfBatch));
failedBatches.addAll(writeOneBatch(secondHalfBatch));
}
} else {
failedBatches.add(failedBatch);
}
}
return failedBatches;
}
/**
* Check whether there are throttling exception in the failed batches.
*/
boolean containsThrottlingException(List failedBatches) {
for (final FailedBatch failedBatch : failedBatches) {
final Exception e = failedBatch.getException();
if (e instanceof AmazonServiceException
&& RetryUtils.isThrottlingException((AmazonServiceException) e)) {
return true;
}
}
return false;
}
/**
* Divide the batch of objects to save into two smaller batches. Each
* contains half of the elements.
*/
private void divideBatch(Map> batch,
Map> firstHalfBatch,
Map> secondHalfBatch) {
for (final String key : batch.keySet()) {
final List requests = batch.get(key);
final List firstHalfRequests = requests.subList(0, requests.size() / 2);
final List secondHalfRequests = requests.subList(requests.size() / 2,
requests.size());
firstHalfBatch.put(key, firstHalfRequests);
secondHalfBatch.put(key, secondHalfRequests);
}
}
/**
* Count the total number of unprocessed items in the failed batch.
*/
private int computeFailedBatchSize(FailedBatch failedBatch) {
int count = 0;
for (final String tableName : failedBatch.getUnprocessedItems().keySet()) {
count += failedBatch.getUnprocessedItems().get(tableName).size();
}
return count;
}
/**
* Continue trying to process the batch until it finishes or an exception
* occurs.
*/
private FailedBatch callUntilCompletion(Map> batch) {
BatchWriteItemResult result = null;
int retries = 0;
FailedBatch failedBatch = null;
while (true) {
try {
result = db.batchWriteItem(applyBatchOperationUserAgent(
new BatchWriteItemRequest().withRequestItems(batch)));
} catch (final Exception e) {
failedBatch = new FailedBatch();
failedBatch.setUnprocessedItems(batch);
failedBatch.setException(e);
return failedBatch;
}
retries++;
batch = result.getUnprocessedItems();
if (batch.size() > 0) {
pauseExponentially(retries);
} else {
break;
}
}
return failedBatch;
}
/**
* Retrieves multiple items from multiple tables using their primary keys.
*
* @see DynamoDBMapper#batchLoad(List, DynamoDBMapperConfig)
* @param itemsToGet list of items to get.
* @return A map of the loaded objects. Each key in the map is the name of a
* DynamoDB table. Each value in the map is a list of objects that
* have been loaded from that table. All objects for each table can
* be cast to the associated user defined type that is annotated as
* mapping that table.
*/
public Map> batchLoad(List