Verwalten von Amazon SQS-Warteschlangen in Java
1. Überblick
In diesem Tutorial erfahren Sie, wie Sieuse Amazon’s SQS (Simple Queue Service) using the Java SDK erreichen.
2. Voraussetzungen
Die Maven-Abhängigkeiten, AWS-Kontoeinstellungen und Clientverbindungen, die zur Verwendung des Amazon AWS SDK für SQS erforderlich sind, sind dieselben wie inthis article here.
Angenommen, wir haben eine Instanz vonAWSCredentials, erstellt, wie im vorherigen Artikel beschrieben, können wir unseren SQS-Client erstellen:
AmazonSQS sqs = AmazonSQSClientBuilder.standard()
.withCredentials(new AWSStaticCredentialsProvider(credentials))
.withRegion(Regions.US_EAST_1)
.build();3. Warteschlangen erstellen
Sobald wir unseren SQS-Client eingerichtet haben, wirdcreating queues is fairly straightforward.
3.1. Erstellen einer Standardwarteschlange
Mal sehen, wie wir eine Standardwarteschlange erstellen können. Dazuwe’ll need to create an instance of CreateQueueRequest:
CreateQueueRequest createStandardQueueRequest = new CreateQueueRequest("example-queue");
String standardQueueUrl = sqs.createQueue(createStandardQueueRequest).getQueueUrl();3.2. Erstellen einer FIFO-Warteschlange
Das Erstellen eines FIFO ähnelt dem Erstellen einer Standardwarteschlange. Wir werden weiterhin eine Instanz vonCreateQueueRequest verwenden, wie wir es zuvor getan haben. Nur diesmalwe’ll have to pass in queue attributes, and set the FifoQueue attribute to true:
Map queueAttributes = new HashMap<>();
queueAttributes.put("FifoQueue", "true");
queueAttributes.put("ContentBasedDeduplication", "true");
CreateQueueRequest createFifoQueueRequest = new CreateQueueRequest(
"example-queue.fifo").withAttributes(queueAttributes);
String fifoQueueUrl = sqs.createQueue(createFifoQueueRequest)
.getQueueUrl(); 4. Nachrichten in Warteschlangen stellen
Sobald wir unsere Warteschlangen eingerichtet haben, können wir mit dem Senden von Nachrichten beginnen.
4.1. Senden einer Nachricht an eine Standardwarteschlange
Um Nachrichten an eine Standardwarteschlange zu senden, werdenhave to create an instance of SendMessageRequest.
Dann fügen wir dieser Anfrage eine Karte mit Nachrichtenattributen hinzu:
Map messageAttributes = new HashMap<>();
messageAttributes.put("AttributeOne", new MessageAttributeValue()
.withStringValue("This is an attribute")
.withDataType("String"));
SendMessageRequest sendMessageStandardQueue = new SendMessageRequest()
.withQueueUrl(standardQueueUrl)
.withMessageBody("A simple message.")
.withDelaySeconds(30)
.withMessageAttributes(messageAttributes);
sqs.sendMessage(sendMessageStandardQueue); DaswithDelaySeconds() gibt an, nach wie langer Zeit die Nachricht in der Warteschlange ankommen soll.
4.2. Senden einer Nachricht an eine FIFO-Warteschlange
Der einzige Unterschied besteht in diesem Fall darin, dasswe’ll have to specify the group to which the message belongs:
SendMessageRequest sendMessageFifoQueue = new SendMessageRequest()
.withQueueUrl(fifoQueueUrl)
.withMessageBody("Another simple message.")
.withMessageGroupId("example-group-1")
.withMessageAttributes(messageAttributes);Wie Sie im obigen Codebeispiel sehen können, geben wir die Gruppe mitwithMessageGroupId(). an
4.3. Mehrere Nachrichten in eine Warteschlange stellen
Wir können auchpost multiple messages to a queue, using a single request. erstellen. Wir erstellen eine Liste vonSendMessageBatchRequestEntry, die wir mit einer Instanz vonSendMessageBatchRequest senden:
List messageEntries = new ArrayList<>();
messageEntries.add(new SendMessageBatchRequestEntry()
.withId("id-1")
.withMessageBody("batch-1")
.withMessageGroupId("example-group-1"));
messageEntries.add(new SendMessageBatchRequestEntry()
.withId("id-2")
.withMessageBody("batch-2")
.withMessageGroupId("example-group-1"));
SendMessageBatchRequest sendMessageBatchRequest
= new SendMessageBatchRequest(fifoQueueUrl, messageEntries);
sqs.sendMessageBatch(sendMessageBatchRequest); 5. Nachrichten aus Warteschlangen lesen
Wir können Nachrichten aus unseren Warteschlangen uminvoking the receiveMessage() method on an instance of ReceiveMessageRequest: empfangen
ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(fifoQueueUrl)
.withWaitTimeSeconds(10)
.withMaxNumberOfMessages(10);
List sqsMessages = sqs.receiveMessage(receiveMessageRequest).getMessages(); MitwithMaxNumberOfMessages(), geben wir an, wie viele Nachrichten aus der Warteschlange abgerufen werden sollen - obwohl zu beachten ist, dass das Maximum10 beträgt.
Die MethodewithWaitTimeSeconds() aktiviertlong-polling. Lange Abfragen sind eine Möglichkeit, die Anzahl der an SQS gesendeten Empfangsnachrichtenanforderungen zu begrenzen.
Einfach ausgedrückt bedeutet dies, dass wir bis zur angegebenen Anzahl von Sekunden warten, um eine Nachricht abzurufen. Wenn sich für diese Dauer keine Nachrichten in der Warteschlange befinden, wird die Anforderung leer zurückgegeben. Wenn während dieser Zeit eine Nachricht in der Warteschlange eintrifft, wird sie zurückgegeben.
Wir könnenget the attributes and body of a given message:
sqsMessages.get(0).getAttributes();
sqsMessages.get(0).getBody();6. Löschen einer Nachricht aus einer Warteschlange
Zum Löschen einer Nachricht verwenden wirDeleteMessageRequest:
sqs.deleteMessage(new DeleteMessageRequest()
.withQueueUrl(fifoQueueUrl)
.withReceiptHandle(sqsMessages.get(0).getReceiptHandle()));7. Warteschlangen für tote Briefe
A dead letter queue must be of the same type as its base queue — it muss FIFO sein, wenn die Basiswarteschlange FIFO ist, und Standard, wenn die Basiswarteschlange Standard ist. In diesem Beispiel verwenden wir eine Standardwarteschlange.
Das erste, was wir tun müssen, istcreate what will become our dead letter queue:
String deadLetterQueueUrl = sqs.createQueue("example-dead-letter-queue").getQueueUrl();Als nächstes werden wirget our newly created queue’s ARN (Amazon Resource Name):
GetQueueAttributesResult deadLetterQueueAttributes = sqs.getQueueAttributes(
new GetQueueAttributesRequest(deadLetterQueueUrl)
.withAttributeNames("QueueArn"));
String deadLetterQueueARN = deadLetterQueueAttributes.getAttributes()
.get("QueueArn");Schließlich haben wirset this newly created queue to be our original standard queue’s dead letter queue:
SetQueueAttributesRequest queueAttributesRequest = new SetQueueAttributesRequest()
.withQueueUrl(standardQueueUrl)
.addAttributesEntry("RedrivePolicy",
"{\"maxReceiveCount\":\"2\", "
+ "\"deadLetterTargetArn\":\"" + deadLetterQueueARN + "\"}");
sqs.setQueueAttributes(queueAttributesRequest);The JSON packet we set in the addAttributesEntry() method when building our SetQueueAttributesRequest instance contains the information we need:maxReceiveCount ist2. Wenn eine Nachricht so oft empfangen wird, wird davon ausgegangen, dass sie nicht korrekt verarbeitet wurde, und an unsere Warteschlange für nicht zustellbare Nachrichten gesendet.
Das AttributdeadLetterTargetArn verweist unsere Standardwarteschlange auf unsere neu erstellte Warteschlange für tote Buchstaben.
8. Überwachung
Wir könnencheck how many messages are currently in a given queue, and how many are in flight with the SDK. Zuerst müssen wirGetQueueAttributesRequest. erstellen
Von dort aus überprüfen wir den Status der Warteschlange:
GetQueueAttributesRequest getQueueAttributesRequest
= new GetQueueAttributesRequest(standardQueueUrl)
.withAttributeNames("All");
GetQueueAttributesResult getQueueAttributesResult
= sqs.getQueueAttributes(getQueueAttributesRequest);
System.out.println(String.format("The number of messages on the queue: %s",
getQueueAttributesResult.getAttributes()
.get("ApproximateNumberOfMessages")));
System.out.println(String.format("The number of messages in flight: %s",
getQueueAttributesResult.getAttributes()
.get("ApproximateNumberOfMessagesNotVisible")));Eine eingehendere Überwachung kann mitAmazon Cloud Watch erreicht werden.
9. Fazit
In diesem Artikel haben wir gesehen, wie manmanage SQS queues using the AWS Java SDK. macht
Wie üblich finden Sie alle im Artikel verwendeten Codebeispiele inover on GitHub.