import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
private void fetchTheValue() {

        final GetItemRequest req = new GetItemRequest().withAttributesToGet("value")
                .withTableName(TableName)
                .withKey(Collections.singletonMap("id", new AttributeValue(this.id)));
        try {
            final GetItemResult result = ddb.getItem(req);
            synchronized (this.monitor) {
                if (result.getItem() == null) {
                    this.x = new RuntimeException("not found: id=" + this.id);
                } else {
                    this.v = result.getItem().get("value").getS();
                    if (this.v == null) {
                        this.x = new RuntimeException("found but no value for: id=" + this.id);
                    }
                }
            }
        } catch (final RuntimeException x) {
            synchronized (this.monitor) {
                this.x = x;
            }
        }

    }
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
/**
 * Get ticket.
 *
 * @param ticketId the ticket id
 * @return the ticket
 */
public Ticket get(final String ticketId) {
    final TicketDefinition metadata = this.ticketCatalog.find(ticketId);
    if (metadata != null) {
        final Map<String, AttributeValue> keys = new HashMap<>();

        keys.put(ColumnNames.ID.getName(), new AttributeValue(ticketId));
        final GetItemRequest request = new GetItemRequest()
                .withKey(keys)
                .withTableName(metadata.getProperties().getStorageName());

        LOGGER.debug("Submitting request [{}] to get ticket item [{}]", request, ticketId);

        final Map<String, AttributeValue> returnItem = amazonDynamoDBClient.getItem(request).getItem();
        if (returnItem != null) {
            final Ticket ticket = deserializeTicket(returnItem);
            LOGGER.debug("Located ticket [{}]", ticket);
            return ticket;
        }
    } else {
        LOGGER.warn("No ticket definition could be found in the catalog to match [{}]", ticketId);
    }
    return null;
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
private Collection<String> fetchChannelLanguages(final String channel) {

        final String id = "channel:" + channel + ":languages";
        final GetItemRequest getItemRequest = new GetItemRequest()
                .withAttributesToGet(Collections.singletonList("value"))
                .withKey(Collections.singletonMap("id", new AttributeValue(id)))
                .withTableName(TableName);
        final GetItemResult getItemResult = ddb.getItem(getItemRequest);
        final Optional<String> maybeValue = Optional.ofNullable(getItemResult.getItem())
                .map(i -> i.get("value"))
                .map(AttributeValue::getS);
        if (!maybeValue.isPresent())
            return Collections.emptyList();

        return Arrays.asList(maybeValue.get().trim().split(" +"));
    }
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
protected DDBTaskResult doInBackground(Void... params) {

		Log.i("doInBackground", "Starting DDBGettask");
		
		DDBTaskResult result = new DDBTaskResult();

		try {
			// Need to specify the key of our item, which is a Map of our primary key attribute(s)
			Map<String, AttributeValue> key = new HashMap<String, AttributeValue>();
			key.put("userid", new AttributeValue().withS("user1234"));
			key.put("recordid", new AttributeValue().withS("highScore"));
			 
			GetItemRequest getItemRequest = new GetItemRequest(AWSClientManager.DDB_TABLE_NAME,key);
			GetItemResult getItemResult = ddb.getItem(getItemRequest);
			 
			result.setAttributeNumber(Integer.parseInt(getItemResult.getItem().get("data").getN()));
			
		} catch (AmazonServiceException ex) {
			ex.printStackTrace();
			Log.e("ddb-get-doInBackground", ex.getMessage());
		}
	
		return result;
	}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
/**
 * Get item of table with provided key-value.
 * 
 * @param tableName
 * @param combinedKey
 * @return
 */
public static Row getRowByKey(String tableName, Key... combinedKey) {
	Map<String, AttributeValue> transformedKey = new HashMap<>();
	for (Key key : combinedKey) {
		transformedKey.put(key.getName(),
				new AttributeValue().withS(key.getValue()));
	}

	GetItemResult result = DynamoDbHandler.CLIENT
			.getItem(new GetItemRequest(tableName, transformedKey));

	List<Attribute> attributes = new ArrayList<>();
	for (String resultKey : result.getItem().keySet()) {
		attributes.add(new Attribute(resultKey, result.getItem()
				.get(resultKey).getS()));
	}

	return new Row(attributes);
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
private Map<String, AttributeValue> readRow(String key, String appid) {
	if (StringUtils.isBlank(key) || StringUtils.isBlank(appid)) {
		return null;
	}
	Map<String, AttributeValue> row = null;
	try {
		GetItemRequest getItemRequest = new GetItemRequest(getTableNameForAppid(appid),
				Collections.singletonMap(Config._KEY, new AttributeValue(getKeyForAppid(key, appid))));
		GetItemResult res = client().getItem(getItemRequest);
		if (res != null && res.getItem() != null && !res.getItem().isEmpty()) {
			row = res.getItem();
		}
	} catch (Exception e) {
		logger.error("Could not read row from DB - appid={}, key={}", appid, key, e);
	}
	return (row == null || row.isEmpty()) ? null : row;
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
public <T> T get(String tableName, Map<String, AttributeValue> key, final ObjectExtractor<T> extractor, String... columnsToInclude) throws EmptyResultDataAccessException {
    Assert.notNull(tableName, "Table must not be null");
    Assert.notNull(extractor, "ObjectExtractor must not be null");
    if (logger.isDebugEnabled()) {
        logger.debug("Executing query on " + tableName + " for " + renderKey(key));
    }

    GetItemRequest request = new GetItemRequest(tableName, key, true);
    if (columnsToInclude != null && columnsToInclude.length > 0) {
        request.setAttributesToGet(Arrays.asList(columnsToInclude));
    }

    GetItemResult result = client.getItem(request);

    Map<String, AttributeValue> item = result.getItem();
    if (item == null) {
        throw new EmptyResultDataAccessException("No results found in " + tableName + "for " + renderKey(key));
    }

    return extractor.extract(item);
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
private static void retrieveItem() {
    try {
        
        HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
        key.put("Id", new AttributeValue().withN("120"));
        GetItemRequest getItemRequest = new GetItemRequest()
            .withTableName(tableName)
            .withKey(key)
            .withProjectionExpression("Id, ISBN, Title, Authors");
        
        GetItemResult result = client.getItem(getItemRequest);

        // Check the response.
        System.out.println("Printing item after retrieving it....");
        printItem(result.getItem());            
                    
    }  catch (AmazonServiceException ase) {
                System.err.println("Failed to retrieve item in " + tableName);
    }   

}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
public static void retrieveItem(String threadId, String replyDateTime) throws IOException {
    HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put("Id", new AttributeValue().withS(threadId));
    key.put("ReplyDateTime", new AttributeValue().withS(replyDateTime));
    
    GetItemRequest getReplyRequest = new GetItemRequest()
        .withTableName(tableName)
        .withKey(key)
        .withConsistentRead(true);
    
    GetItemResult getReplyResult = client.getItem(getReplyRequest);
    
    // Decompress the reply message and print
    Map<String, AttributeValue> reply = getReplyResult.getItem();
    String message = decompressString(reply.get("ExtendedMessage").getB());
    System.out.println("Reply message:\n"
        + " Id: " + reply.get("Id").getS() + "\n" 
        + " ReplyDateTime: " + reply.get("ReplyDateTime").getS() + "\n" 
        + " PostedBy: " + reply.get("PostedBy").getS() + "\n"
        + " Message: " + reply.get("Message").getS() + "\n"
        + " ExtendedMessage (decompressed): " + message);
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
/**
 * Returns the list of usernames stored in the user table.
 */
public void describeUser(String username, String userTable) {
    HashMap<String, AttributeValue> key = new HashMap<String, AttributeValue>();
    key.put("username", new AttributeValue().withS(username));

    GetItemRequest getItemRequest = new GetItemRequest()
            .withTableName(userTable)
            .withKey(key);

    Map<String, AttributeValue> list = ddb.getItem(getItemRequest).getItem();
    if (list.isEmpty()) {
        System.err.println("No record found for username '" + username + "'");
        return;
    }

    for (Entry<String, AttributeValue> entry : list.entrySet()) {
        System.out.println(entry.getKey() + " = " + entry.getValue().getS());
    }
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
@Override
protected Row executePrimaryKeyLookupQuery(Table table, List<SelectItem> selectItems, Column primaryKeyColumn,
        Object keyValue) {
    final List<String> attributeNames = new ArrayList<>();
    for (SelectItem selectItem : selectItems) {
        attributeNames.add(selectItem.getColumn().getName());
    }

    final GetItemRequest getItemRequest = new GetItemRequest(table.getName(), Collections.singletonMap(
            primaryKeyColumn.getName(), DynamoDbUtils.toAttributeValue(keyValue))).withAttributesToGet(
                    attributeNames);
    final GetItemResult item = _dynamoDb.getItem(getItemRequest);

    final Object[] values = new Object[selectItems.size()];
    for (int i = 0; i < values.length; i++) {
        final AttributeValue attributeValue = item.getItem().get(attributeNames.get(i));
        values[i] = DynamoDbUtils.toValue(attributeValue);
    }

    return new DefaultRow(new SimpleDataSetHeader(selectItems), values);
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
public GetPointResult getPoint(GetPointRequest getPointRequest) {
	long geohash = S2Manager.generateGeohash(getPointRequest.getGeoPoint());
	long hashKey = S2Manager.generateHashKey(geohash, config.getHashKeyLength());

	GetItemRequest getItemRequest = getPointRequest.getGetItemRequest();
	getItemRequest.setTableName(config.getTableName());

	AttributeValue hashKeyValue = new AttributeValue().withN(String.valueOf(hashKey));
	getItemRequest.getKey().put(config.getHashKeyAttributeName(), hashKeyValue);
	getItemRequest.getKey().put(config.getRangeKeyAttributeName(), getPointRequest.getRangeKeyValue());

	GetItemResult getItemResult = config.getDynamoDBClient().getItem(getItemRequest);
	GetPointResult getPointResult = new GetPointResult(getItemResult);

	return getPointResult;
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
private RegisteredService getRegisteredServiceByKeys(final Map<String, AttributeValue> keys) {
    final GetItemRequest request = new GetItemRequest()
            .withKey(keys)
            .withTableName(TABLE_NAME);

    LOGGER.debug("Submitting request [{}] to get service with keys [{}]", request, keys);
    final Map<String, AttributeValue> returnItem = amazonDynamoDBClient.getItem(request).getItem();
    if (returnItem != null) {
        final RegisteredService service = deserializeServiceFromBinaryBlob(returnItem);
        LOGGER.debug("Located service [{}]", service);
        return service;
    }
    return null;
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
private Mono<GetItemResult> getItemResultMono(String url) {

        GetItemRequest getItemRequest = new GetItemRequest();
        getItemRequest.setTableName(Utils.table.websites);
        HashMap<String, AttributeValue> key = new HashMap<>();
        key.put(Utils.params.url, new AttributeValue(url));
        getItemRequest.setKey(key);

        return Mono.fromFuture(
                Utils.makeCompletableFuture(
                        dynamoDBAsync.getItemAsync(getItemRequest)))
                .doOnError((throwable -> LOG.error(Utils.error.failed_dynamo_get, url)));
    }
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
private GetItemRequest getItemRequest(String url) {

        GetItemRequest request = new GetItemRequest();
        request.setTableName(Utils.table.websites);
        HashMap<String, AttributeValue> key = new HashMap<>();
        key.put(Utils.params.url, new AttributeValue(url));
        request.setKey(key);

        return request;
    }
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
private Optional<String> googleToken(final String team) {
    final String id = "team:" + team + ":googletoken";
    final GetItemRequest getItemRequest = new GetItemRequest()
            .withAttributesToGet(Collections.singletonList("value"))
            .withKey(Collections.singletonMap("id", new AttributeValue(id)))
            .withTableName(TableName);
    final GetItemResult getItemResult = ddb.getItem(getItemRequest);
    return Optional.ofNullable(getItemResult.getItem()).map(i -> i.get("value")).map(AttributeValue::getS);
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
public CompletableFuture<Map<String, Object>> getItem(final GetItemRequest getItemRequest) {
    return asyncExecutor.execute(new Callable<Map<String, Object>>() {
        @Override
        public Map<String, Object> call() throws Exception {
            return dbExecutor.getItem(getItemRequest);
        }
    });
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
@Override
public void execute() {
    GetItemResult result = ddbClient.getItem(new GetItemRequest()
            .withKey(determineKey())
            .withTableName(determineTableName())
            .withAttributesToGet(determineAttributeNames())
            .withConsistentRead(determineConsistentRead()));
    addAttributesToResult(result.getItem());
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
GetItemResult getItem(final GetItemRequest request) throws BackendException {
    setUserAgent(request);
    GetItemResult result;
    timedReadThrottle(GET_ITEM, request.getTableName(), estimateCapacityUnits(GET_ITEM, request.getTableName()));
    final Timer.Context apiTimerContext = getTimerContext(GET_ITEM, request.getTableName());
    try {
        result = client.getItem(request);
    } catch (Exception e) {
        throw processDynamoDbApiException(e, GET_ITEM, request.getTableName());
    } finally {
        apiTimerContext.stop();
    }
    meterConsumedCapacity(GET_ITEM, result.getConsumedCapacity());
    return result;
}
 

import com.amazonaws.services.dynamodbv2.model.GetItemRequest; //导入依赖的package包/类
@Override
public EntryList getSlice(final KeySliceQuery query, final StoreTransaction txh) throws BackendException {
    log.debug("Entering getSliceKeySliceQuery table:{} query:{} txh:{}", getTableName(), encodeForLog(query), txh);
    final GetItemRequest request = super.createGetItemRequest().withKey(new ItemBuilder().hashKey(query.getKey()).build());
    final GetItemResult result = new ExponentialBackoff.GetItem(request, client.getDelegate()).runWithBackoff();

    final List<Entry> filteredEntries = extractEntriesFromGetItemResult(result, query.getSliceStart(), query.getSliceEnd(), query.getLimit());
    log.debug("Exiting getSliceKeySliceQuery table:{} query:{} txh:{} returning:{}", getTableName(), encodeForLog(query), txh,
              filteredEntries.size());
    return StaticArrayEntryList.of(filteredEntries);
}