Java DeleteMessageBatchRequest类代码示例

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
private List<String> delete(List<Message> messages) {
if (messages == null || messages.isEmpty()) {
          return null;
      }

      DeleteMessageBatchRequest batch = new DeleteMessageBatchRequest().withQueueUrl(queueURL);
  	List<DeleteMessageBatchRequestEntry> entries = batch.getEntries();

  	messages.stream().forEach(m -> entries.add(new DeleteMessageBatchRequestEntry().withId(m.getId()).withReceiptHandle(m.getReceipt())));
      
      DeleteMessageBatchResult result = client.deleteMessageBatch(batch);
      List<String> failures = result.getFailed().stream().map(fm -> fm.getId()).collect(Collectors.toList());
logger.debug("failed to delete: {}", failures);
      return failures;

  }
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
@Override
public void releaseCompleteScanRanges(Collection<ScanRangeComplete> completions) {
    if (completions.isEmpty()) {
        return;
    }

    int id = 0;
    List<DeleteMessageBatchRequestEntry> entries = Lists.newArrayListWithCapacity(completions.size());
    for (ScanRangeComplete completion : completions) {
        entries.add(
                new DeleteMessageBatchRequestEntry()
                        .withId(String.valueOf(id++))
                        .withReceiptHandle(((QueueScanRangeComplete) completion).getMessageId()));
    }

    _sqs.deleteMessageBatch(new DeleteMessageBatchRequest()
            .withQueueUrl(getQueueUrl(_completeScanRangeQueue))
            .withEntries(entries));
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
/***
 * Handle Messages
 * @param queue
 * @param sqsMessages
 */
private void handleMessages(final String queue, final List<com.amazonaws.services.sqs.model.Message> sqsMessages) {
	
	final List<Message> messages =  fromSqsMessages(queue, sqsMessages);
	if(CollectionUtil.hasElements(messages)){
		
		this.handler.handleBatch(messages);
		final List<DeleteMessageBatchRequestEntry> deleteEntries = new ArrayList<DeleteMessageBatchRequestEntry>();

		/*** TODO Allow the caller to specify messages to delete **/
		for(com.amazonaws.services.sqs.model.Message sqsMessage : sqsMessages){
			final DeleteMessageBatchRequestEntry entry = new DeleteMessageBatchRequestEntry(sqsMessage.getMessageId(), sqsMessage.getReceiptHandle());
			deleteEntries.add(entry);
		}
		/** Delete the message batch - TODO - This should actually Respect the feedback given from the handler on which messages to delete**/ 
		this.client.deleteMessageBatch(
				new DeleteMessageBatchRequest(this.queueUrl)
				.withEntries(deleteEntries));
	}
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
/**
 * Tests a simple send, receive and delete of a message from the queue
 * resource. Asserts the message contents and its associated attributes.
 */
@Test
@Ignore
public void testSendReceiveDelete() throws InterruptedException {
    SendMessageResult sendMessageResult = queue.sendMessage(TEST_MESSAGE);
    assertNotNull(sendMessageResult);
    assertNotNull(sendMessageResult.getMessageId());

    List<Message> messages = waitForMessagesFromQueue(null);

    assertNotNull(messages);
    assertEquals(1, messages.size());
    Message message = messages.get(0);
    assertMessage(TEST_MESSAGE, sendMessageResult.getMessageId(),
            sendMessageResult.getMD5OfMessageBody(), message);

    queue.deleteMessages(new DeleteMessageBatchRequest()
            .withEntries(new DeleteMessageBatchRequestEntry("msg1", message
                    .getReceiptHandle())));
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
@Override
public DeleteMessageBatchResult deleteMessageBatch(DeleteMessageBatchRequest deleteMessageBatchRequest) throws AmazonClientException {
    DirectorySQSQueue queue = getQueueFromUrl(deleteMessageBatchRequest.getQueueUrl(), false);
    //lists for reporting
    List<BatchResultErrorEntry> batchResultErrorEntries = new ArrayList<>();
    List<DeleteMessageBatchResultEntry> batchResultEntries = new ArrayList<>();
    //attempt delete on each
    for (DeleteMessageBatchRequestEntry batchRequestEntry : deleteMessageBatchRequest.getEntries()) {
        try {
            queue.delete(batchRequestEntry.getReceiptHandle());
            batchResultEntries.add(new DeleteMessageBatchResultEntry().withId(batchRequestEntry.getId()));
        } catch (IOException e) {
            BatchResultErrorEntry batchResultErrorEntry = new BatchResultErrorEntry().
                    withSenderFault(true).
                    withId(batchRequestEntry.getId()).
                    withMessage(e.getMessage());
            batchResultErrorEntries.add(batchResultErrorEntry);
        }
    }
    return new DeleteMessageBatchResult().withFailed(batchResultErrorEntries).withSuccessful(batchResultEntries);
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
@VisibleForTesting
static DeleteMessageBatchRequest createRequest(String queueUrl, Map<String, DeleteMessageEntry> entries) {
    return new DeleteMessageBatchRequest()
            .withQueueUrl(queueUrl)
            .withEntries(entries.entrySet().stream()
                    .map(keyValue -> new DeleteMessageBatchRequestEntry()
                            .withId(keyValue.getKey())
                            .withReceiptHandle(keyValue.getValue().getReceiptHandle())
                    ).collect(Collectors.toList()));
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
@Override
public DeleteMessageBatchRequest createDeleteMessageBatchRequest(String queueUrl, List<Message> messages) {
    final List<DeleteMessageBatchRequestEntry> entries = new ArrayList<>(messages.size());

    for (final Message message : messages) {
        final DeleteMessageBatchRequestEntry entry = this.createDeleteMessageBatchRequestEntry(message);
        entries.add(entry);
    }

    final DeleteMessageBatchRequest request = new DeleteMessageBatchRequest(queueUrl);
    request.setEntries(entries);
    return request;
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
@Override
public DeleteMessageBatchResult deleteMessages(DeleteMessageBatchRequest
        request, ResultCapture<DeleteMessageBatchResult> extractor) {

    ActionResult result = resource.performAction("DeleteMessages", request,
            extractor);

    if (result == null) return null;
    return (DeleteMessageBatchResult) result.getData();
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
/**
 * Acknowledges up to 10 messages via calling
 * <code>deleteMessageBatch</code>.
 */
@Override
public void action(String queueUrl, List<String> receiptHandles) throws JMSException {
    if (receiptHandles == null || receiptHandles.isEmpty()) {
        return;
    }

    List<DeleteMessageBatchRequestEntry> deleteMessageBatchRequestEntries = new ArrayList<DeleteMessageBatchRequestEntry>();
    int batchId = 0;
    for (String receiptHandle : receiptHandles) {
        // Remove the message from queue of unAckMessages
        unAckMessages.poll();
        
        DeleteMessageBatchRequestEntry entry = new DeleteMessageBatchRequestEntry(
                Integer.toString(batchId), receiptHandle);
        deleteMessageBatchRequestEntries.add(entry);
        batchId++;
    }
    
    DeleteMessageBatchRequest deleteMessageBatchRequest = new DeleteMessageBatchRequest(
            queueUrl, deleteMessageBatchRequestEntries);
    /**
     * TODO: If one of the batch calls fail, then the remaining messages on
     * the batch will not be deleted, and will be visible and delivered as
     * duplicate after visibility timeout expires.
     */
    amazonSQSClient.deleteMessageBatch(deleteMessageBatchRequest);
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
@Test(expected = JMSException.class)
public void testDeleteMessageBatchThrowAmazonClientException() throws JMSException {

    DeleteMessageBatchRequest deleteMessageBatchRequest = new DeleteMessageBatchRequest();
    doThrow(new AmazonClientException("ace"))
            .when(amazonSQSClient).deleteMessageBatch(eq(deleteMessageBatchRequest));

    wrapper.deleteMessageBatch(deleteMessageBatchRequest);
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
@Test(expected = JMSException.class)
public void testDeleteMessageBatchThrowAmazonServiceException() throws JMSException {

    DeleteMessageBatchRequest deleteMessageBatchRequest = new DeleteMessageBatchRequest();
    doThrow(new AmazonServiceException("ase"))
            .when(amazonSQSClient).deleteMessageBatch(eq(deleteMessageBatchRequest));

    wrapper.deleteMessageBatch(deleteMessageBatchRequest);
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
private void delete(String queue, List<Message> messages) {
    List<DeleteMessageBatchRequestEntry> deleteRequests = new ArrayList<DeleteMessageBatchRequestEntry>(); 

    for(Message m : messages) {
        deleteRequests.add(new DeleteMessageBatchRequestEntry().withId(m.getMessageId()).withReceiptHandle(m.getReceiptHandle()));
    }

    log.info(format("Deleting %s messages", deleteRequests.size()));

    DeleteMessageBatchRequest batchDelete = new DeleteMessageBatchRequest();
    batchDelete.setQueueUrl(queue);
    batchDelete.setEntries(deleteRequests);

    sqs.deleteMessageBatch(batchDelete);
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
@Test
public void testCreateRequest() {
    DeleteMessageBatchRequest request = DeleteMessageBatchAction.createRequest(QUEUE_URL, ENTRY_MAP);
    assertThat(request.getQueueUrl()).isEqualTo(QUEUE_URL);
    assertThat(request.getEntries().size()).isEqualTo(ENTRY_MAP.size());
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
@Test
public void testBulkSendDelete_shouldWork() {
  // create queue
  CreateQueueResult createdQueue = sqs.createQueue(new CreateQueueRequest().withQueueName("tea-earl-grey-queue"));
  // send batch
  SendMessageBatchRequestEntry firstRequest = new SendMessageBatchRequestEntry().withDelaySeconds(0).withId("one")
      .withMessageGroupId("groupee").withMessageBody("{\"XOXO\":234}");
  SendMessageBatchRequestEntry secondRequest = new SendMessageBatchRequestEntry().withDelaySeconds(0).withId("two")
      .withMessageGroupId("groupee").withMessageBody("{\"Quinoa\":\"Readymade\",\"vegan\":true}");
  SendMessageBatchRequestEntry thirdRequest = new SendMessageBatchRequestEntry().withDelaySeconds(0).withId("three")
      .withMessageGroupId("groupee").withMessageBody("{\"VHS\":\"street art slow-carb\"}");
  // verify send batch result
  SendMessageBatchResult sendResult = sqs.sendMessageBatch(new SendMessageBatchRequest().withQueueUrl(createdQueue.getQueueUrl())
      .withEntries(ImmutableList.of(firstRequest,secondRequest, thirdRequest)));
  assertNotNull("verify that batch send returned ok", sendResult);
  assertTrue("no request failed",sendResult.getFailed().isEmpty());
  assertEquals("verify successfull message count", 3, sendResult.getSuccessful().size());
  SendMessageBatchResultEntry firstResultEntry = sendResult.getSuccessful().stream().filter(msg -> msg.getId().equals("one")).findAny().get();
  assertEquals("verify correct message MD5",getAwsMessageMD5("{\"XOXO\":234}"),firstResultEntry.getMD5OfMessageBody());
  assertNotNull("verify message id exists",firstResultEntry.getMessageId());

  ReceiveMessageResult receivedMessagesResult = sqs.receiveMessage(new ReceiveMessageRequest().withQueueUrl(createdQueue.getQueueUrl()).withMaxNumberOfMessages(4));
  // delete batch
  List<DeleteMessageBatchRequestEntry> deleteRequests = new ArrayList<>();
  deleteRequests.add(new DeleteMessageBatchRequestEntry().withId("one").withReceiptHandle(receivedMessagesResult.getMessages().get(0).getReceiptHandle()));
  deleteRequests.add(new DeleteMessageBatchRequestEntry().withId("two").withReceiptHandle(receivedMessagesResult.getMessages().get(0).getReceiptHandle()));
  deleteRequests.add(new DeleteMessageBatchRequestEntry().withId("three").withReceiptHandle(receivedMessagesResult.getMessages().get(0).getReceiptHandle())); 
  
  DeleteMessageBatchResult deleteBatchResult = sqs.deleteMessageBatch(new DeleteMessageBatchRequest().withQueueUrl(createdQueue.getQueueUrl()).withEntries(deleteRequests));
  
  // verify delete batch result
  assertNotNull("verify that batch delete returned ok", deleteBatchResult);
  assertTrue("no request failed",deleteBatchResult.getFailed().isEmpty());
  assertEquals("verify successfull message count", 3, deleteBatchResult.getSuccessful().size());
  assertTrue("queue must be empty after removal",getQueues().get("tea-earl-grey-queue").getMessageQueue().isEmpty());
  for(Message message : receivedMessagesResult.getMessages()) {
    assertTrue("invisibility-queue must be empty after removal",getQueues().get("tea-earl-grey-queue").getInvisibilityQueueFor(message.getReceiptHandle()).isEmpty());
  }
  
  // cleanup
  getQueues().remove("tea-earl-grey-queue");
}
 

import com.amazonaws.services.sqs.model.DeleteMessageBatchRequest; //导入依赖的package包/类
@Test
public void testBulkDelete_withEmptyRequestParams_shouldWork() {
  assertNotNull(sqs.deleteMessageBatch(new DeleteMessageBatchRequest()));
}