Java PutItemRequest.setItem方法代码示例

import com.amazonaws.services.dynamodbv2.model.PutItemRequest; //导入方法依赖的package包/类
private Mono<Map<String, AttributeValue>> putItemResultMono(
        String seedUrl,
        EStatus status,
        String title,
        WebsiteModel websiteModel
) {

    PutItemRequest putItemRequest = new PutItemRequest();
    putItemRequest.setTableName(Utils.table.websites);

    Map<String, AttributeValue> newWebsite = new HashMap<>();

    if (Objects.nonNull(websiteModel)) newWebsite = crawlerBatchService.getNodes(websiteModel);
    newWebsite.put(Utils.params.url, new AttributeValue(seedUrl));
    newWebsite.put(Utils.params.status, new AttributeValue(status.name()));
    if (StringUtils.isNotEmpty(title)) newWebsite.put(Utils.params.title, new AttributeValue(title));

    putItemRequest.setItem(newWebsite);

    return Mono.fromFuture(
            Utils.makeCompletableFuture(
                    dynamoDBAsync.putItemAsync(putItemRequest)))
            .doOnError((throwable -> LOG.error(Utils.error.failed_dynamo_put, seedUrl)))
            .doOnSuccess((a) -> LOG.info(Utils.success.saved_dynamo, String.format("%s [%s]", seedUrl, status)))
            .map(((result) -> putItemRequest.getItem()));
}
 

import com.amazonaws.services.dynamodbv2.model.PutItemRequest; //导入方法依赖的package包/类
private Mono<Map<String, AttributeValue>> putItemResultMono(String url) {

        PutItemRequest putItemRequest = new PutItemRequest();
        putItemRequest.setTableName(Utils.table.websites);
        HashMap<String, AttributeValue> newWebsite = new HashMap<>();
        newWebsite.put(Utils.params.url, new AttributeValue(url));
        newWebsite.put(Utils.params.status, new AttributeValue(EStatus.NEW.name()));
        putItemRequest.setItem(newWebsite);

        return Mono.fromFuture(
                Utils.makeCompletableFuture(
                        dynamoDBAsync.putItemAsync(putItemRequest)))
                .doOnError((throwable -> LOG.error(Utils.error.failed_dynamo_put, url)))
                .flatMap((created) -> this.sendMessage(url))
                .map(((result) -> putItemRequest.getItem()));
    }
 

import com.amazonaws.services.dynamodbv2.model.PutItemRequest; //导入方法依赖的package包/类
@Override
public Item put(final Map<String, AttributeValue> attributes)
    throws IOException {
    final AmazonDynamoDB aws = this.credentials.aws();
    try {
        final PutItemRequest request = new PutItemRequest();
        request.setTableName(this.self);
        request.setItem(attributes);
        request.setReturnValues(ReturnValue.NONE);
        request.setReturnConsumedCapacity(ReturnConsumedCapacity.TOTAL);
        final PutItemResult result = aws.putItem(request);
        final long start = System.currentTimeMillis();
        Logger.info(
            this, "#put('%[text]s'): created item in '%s', %s, in %[ms]s",
            attributes, this.self,
            new PrintableConsumedCapacity(
                result.getConsumedCapacity()
            ).print(),
            System.currentTimeMillis() - start
        );
        return new AwsItem(
            this.credentials,
            this.frame(),
            this.self,
            new Attributes(attributes).only(this.keys()),
            new Array<String>(this.keys())
        );
    } catch (final AmazonClientException ex) {
        throw new IOException(
            String.format(
                "failed to put into \"%s\" with %s",
                this.self, attributes
            ),
            ex
        );
    } finally {
        aws.shutdown();
    }
}
 

import com.amazonaws.services.dynamodbv2.model.PutItemRequest; //导入方法依赖的package包/类
@Override
public <T extends Message> void insert(T item, Modifier... modifiers) throws DataStoreException {
  DynamoClassMapping<T> tableInfo = getClassMapping(item);

  log.debug("Insert {} {}", item.getClass().getSimpleName(), item);
  for (Modifier modifier : modifiers) {
    throw new UnsupportedOperationException();
  }

  PutItemRequest request = new PutItemRequest();
  request.setTableName(tableInfo.getDynamoTableName());

  Map<String, AttributeValue> itemData = tableInfo.mapToDb(item);
  request.setItem(itemData);

  Map<String, ExpectedAttributeValue> expected = Maps.newHashMap();
  expected.put(FIELD_HASH_KEY, new ExpectedAttributeValue().withComparisonOperator(ComparisonOperator.NULL));
  request.setExpected(expected);
  if (expected.size() > 1) {
    request.setConditionalOperator(ConditionalOperator.AND);
  }

  try {
    dynamoDB.putItem(request);
  } catch (ConditionalCheckFailedException e) {
    log.debug("Insert failed {}", item, e);

    throw new UniqueIndexViolation(null);
  }
}
 

import com.amazonaws.services.dynamodbv2.model.PutItemRequest; //导入方法依赖的package包/类
public PutPointRequest(GeoPoint geoPoint, AttributeValue rangeKeyValue) {
	putItemRequest = new PutItemRequest();
	putItemRequest.setItem(new HashMap<String, AttributeValue>());
	putRequest = new PutRequest();
	putRequest.setItem(new HashMap<String, AttributeValue>());
	
	this.geoPoint = geoPoint;
	this.rangeKeyValue = rangeKeyValue;
}
 

import com.amazonaws.services.dynamodbv2.model.PutItemRequest; //导入方法依赖的package包/类
public <T extends Message> List<T> reindex(T instance) throws DataStoreException {
  DynamoClassMapping<T> tableInfo = getClassMapping(instance);

  log.debug("reindex {}", instance.getClass().getSimpleName());

  ScanRequest scanRequest = new ScanRequest();
  scanRequest.setTableName(tableInfo.getDynamoTableName());

  // TODO: Filter expressions on prefix?

  ScanResult scanResponse = dynamoDB.scan(scanRequest);

  Map<String, AttributeValue> lastEvaluatedKey = scanResponse.getLastEvaluatedKey();
  if (lastEvaluatedKey != null) {
    throw new UnsupportedOperationException("Multiple page results not implemented");
  }

  List<T> items = Lists.newArrayList();
  List<Map<String, AttributeValue>> responseItems = scanResponse.getItems();
  for (Map<String, AttributeValue> itemData : responseItems) {
    if (!tableInfo.matchesType(itemData)) {
      continue;
    }

    T item = tableInfo.mapFromDb(itemData);

    Map<String, AttributeValue> newItemData = tableInfo.mapToDb(item);

    if (DynamoDbHelpers.areEqual(itemData, newItemData)) {
      log.debug("No change for item: {}", itemData);
      continue;
    }

    PutItemRequest putRequest = new PutItemRequest();
    putRequest.setTableName(tableInfo.getDynamoTableName());
    putRequest.setItem(itemData);
    dynamoDB.putItem(putRequest);

    Map<String, AttributeValue> oldKey = extractKey(itemData);
    Map<String, AttributeValue> newKey = extractKey(newItemData);

    if (!DynamoDbHelpers.areEqual(oldKey, newKey)) {
      DeleteItemRequest deleteItemRequest = new DeleteItemRequest();
      deleteItemRequest.setTableName(tableInfo.getDynamoTableName());
      deleteItemRequest.setKey(oldKey);
      dynamoDB.deleteItem(deleteItemRequest);
    }

  }

  return items;
}