Queue Storage gebruiken vanuit Java
Overzicht
In deze handleiding ziet u hoe u code kunt uitvoeren voor veelvoorkomende scenario's met behulp van de Azure Queue Storage-service. De voorbeelden worden geschreven in Java en gebruiken de Azure Storage SDK voor Java. Scenario's omvatten het invoegen van, bekijken, ophalen en het verwijderen van wachtrijberichten. Code voor het maken van wachtrijen met en het verwijderen van wachtrijen met wordt ook behandeld. Zie de sectie Volgende stappen voor meer informatie over wachtrijen.
Wat is wachtrijopslag?
Azure Queue Storage is een service voor het opslaan van grote aantallen berichten die overal ter wereld toegankelijk zijn via geverifieerde aanroepen via HTTP of HTTPS. Eén wachtrijbericht kan maximaal 64 kB groot zijn en een wachtrij kan miljoenen berichten bevatten, tot aan de totale capaciteitslimiet van een opslagaccount. Queue Storage wordt vaak gebruikt om een wachtrij van taken te maken voor asynchrone verwerking.
Concepten van wachtrijservice
De Azure Queue-service bevat de volgende onderdelen:
opslagaccount: Alle toegang tot Azure Storage wordt uitgevoerd via een opslagaccount. Zie Overzicht van opslagaccount voor meer informatie over opslagaccounts.
Wachtrij: Een wachtrij bevat een set berichten. Alle berichten moeten zich in een wachtrij bevinden. De naam van een wachtrij mag alleen kleine letters bevatten. Zie Naming Queues and Metadata (Wachtrijen en metagegevens een naam geven) voor informatie over de naamgeving van wachtrijen.
Bericht: Een bericht in een willekeurige indeling, van maximaal 64 KB. De maximale tijd dat een bericht in de wachtrij kan blijven, is 7 dagen. Voor versie 29-07-2017 of hoger mag de maximale time-to-live elk positief getal zijn. Of -1 om aan te geven dat het bericht niet verloopt. Als deze parameter wordt weggelaten, is de standaard time-to-live zeven dagen.
URL-indeling: wachtrijen kunnen worden aangesproken met behulp van de volgende URL-indeling: http://
<storage account>.queue.core.windows.net/<queue>De volgende URL verwijst naar een wachtrij in het diagram.
http://myaccount.queue.core.windows.net/incoming-orders
Een Azure-opslagaccount maken
De eenvoudigste manier om uw eerste Azure-opslagaccount te maken, is met behulp van de Azure Portal. Zie: Een opslagaccount maken voor meer informatie.
U kunt ook een Azure-opslagaccount maken met behulp van Azure PowerShell-, Azure CLI-of de Azure Storage-resourceprovider voor .NET.
Als u op dit moment liever geen opslagaccount in Azure wilt maken, kunt u ook de Emulator van de Azurite-opslag gebruiken om uw code in een lokale omgeving uit te voeren en te testen. Zie De Azurite-emulator gebruiken voor lokale Azure Storage-ontwikkelingvoor meer informatie.
Een Java-toepassing maken
Controleer eerst of uw ontwikkelsysteem voldoet aan de vereisten die worden vermeld in Azure Queue Storage-clientbibliotheek v12 voor Java.
Een Java-toepassing maken met de naam queues-how-to-v12:
Gebruik Maven in een consolevenster (zoals cmd, PowerShell of Bash) om een nieuwe console-app te maken met de naam
queues-how-to-v12. Typ de volgendemvnopdracht om een 'hallo wereld' Java-project te maken.mvn archetype:generate \ --define interactiveMode=n \ --define groupId=com.queues.howto \ --define artifactId=queues-howto-v12 \ --define archetypeArtifactId=maven-archetype-quickstart \ --define archetypeVersion=1.4mvn archetype:generate ` --define interactiveMode=n ` --define groupId=com.queues.howto ` --define artifactId=queues-howto-v12 ` --define archetypeArtifactId=maven-archetype-quickstart ` --define archetypeVersion=1.4De uitvoer van het project zou er ongeveer als volgt moeten uitzien:
[INFO] Scanning for projects... [INFO] [INFO] ------------------< org.apache.maven:standalone-pom >------------------- [INFO] Building Maven Stub Project (No POM) 1 [INFO] --------------------------------[ pom ]--------------------------------- [INFO] [INFO] >>> maven-archetype-plugin:3.1.2:generate (default-cli) > generate-sources @ standalone-pom >>> [INFO] [INFO] <<< maven-archetype-plugin:3.1.2:generate (default-cli) < generate-sources @ standalone-pom <<< [INFO] [INFO] [INFO] --- maven-archetype-plugin:3.1.2:generate (default-cli) @ standalone-pom --- [INFO] Generating project in Batch mode [INFO] ---------------------------------------------------------------------------- [INFO] Using following parameters for creating project from Archetype: maven-archetype-quickstart:1.4 [INFO] ---------------------------------------------------------------------------- [INFO] Parameter: groupId, Value: com.queues.howto [INFO] Parameter: artifactId, Value: queues-howto-v12 [INFO] Parameter: version, Value: 1.0-SNAPSHOT [INFO] Parameter: package, Value: com.queues.howto [INFO] Parameter: packageInPathFormat, Value: com/queues/howto [INFO] Parameter: version, Value: 1.0-SNAPSHOT [INFO] Parameter: package, Value: com.queues.howto [INFO] Parameter: groupId, Value: com.queues.howto [INFO] Parameter: artifactId, Value: queues-howto-v12 [INFO] Project created from Archetype in dir: C:\queues\queues-howto-v12 [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 6.775 s [INFO] Finished at: 2020-08-17T15:27:31-07:00 [INFO] ------------------------------------------------------------------------Schakel over naar de zojuist gemaakte
queues-howto-v12map.cd queues-howto-v12
Het pakket installeren
Open het pom.xml bestand in de teksteditor. Voeg het volgende afhankelijkheidselement toe aan de groep met afhankelijkheden.
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-storage-queue</artifactId>
<version>12.6.0</version>
</dependency>
Uw toepassing configureren voor toegang tot Queue Storage
Voeg de volgende importinstructies toe aan het begin van het Java-bestand waar u Azure Storage-API's wilt gebruiken voor toegang tot wachtrijen:
// Include the following imports to use queue APIs
import com.azure.core.util.*;
import com.azure.storage.queue.*;
import com.azure.storage.queue.models.*;
Een Azure-opslagverbindingstekenreeks instellen
Een Azure Storage-client maakt gebruik van een opslagverbindingsreeks voor toegang tot gegevensbeheerservices. Haal de naam en de primaire toegangssleutel op voor uw opslagaccount die worden vermeld in de Azure portal. Gebruik ze als de AccountName en AccountKey waarden in de verbindingsreeks. In dit voorbeeld ziet u hoe u een statisch veld kunt declareren voor het opslaan van de verbindingstekenreeks:
// Define the connection-string with your values
final String connectStr =
"DefaultEndpointsProtocol=https;" +
"AccountName=your_storage_account;" +
"AccountKey=your_storage_account_key";
In de volgende voorbeelden wordt ervan uitgegaan dat u een String-object hebt met de opslagverbindingsreeks.
Hoe te: Een wachtrij maken
Een QueueClient-object bevat de bewerkingen voor interactie met een wachtrij. Met de volgende code wordt een QueueClient-object gemaakt. Gebruik het QueueClient-object om de wachtrij te maken die u wilt gebruiken.
public static String createQueue(String connectStr)
{
try
{
// Create a unique name for the queue
String queueName = "queue-" + java.util.UUID.randomUUID();
System.out.println("Creating queue: " + queueName);
// Instantiate a QueueClient which will be
// used to create and manipulate the queue
QueueClient queue = new QueueClientBuilder()
.connectionString(connectStr)
.queueName(queueName)
.buildClient();
// Create the queue
queue.create();
return queue.getQueueName();
}
catch (QueueStorageException e)
{
// Output the exception message and stack trace
System.out.println("Error code: " + e.getErrorCode() + "Message: " + e.getMessage());
return null;
}
}
Procedure: Een bericht toevoegen aan een wachtrij
Als u een bericht in een bestaande wachtrij wilt invoegen, roept u de methode sendMessage aan. Een bericht kan een tekenreeks (in UTF-8-indeling) of een bytematrix zijn. Hier volgt code waarmee een tekenreeksbericht naar de wachtrij wordt verzonden.
public static void addQueueMessage
(String connectStr, String queueName, String messageText)
{
try
{
// Instantiate a QueueClient which will be
// used to create and manipulate the queue
QueueClient queueClient = new QueueClientBuilder()
.connectionString(connectStr)
.queueName(queueName)
.buildClient();
System.out.println("Adding message to the queue: " + messageText);
// Add a message to the queue
queueClient.sendMessage(messageText);
}
catch (QueueStorageException e)
{
// Output the exception message and stack trace
System.out.println(e.getMessage());
e.printStackTrace();
}
}
Procedure: Kijken naar het volgende bericht
U kunt het bericht aan de voorkant van een wachtrij bekijken zonder het uit de wachtrij te verwijderen door peekMessageaan te roepen.
public static void peekQueueMessage
(String connectStr, String queueName)
{
try
{
// Instantiate a QueueClient which will be
// used to create and manipulate the queue
QueueClient queueClient = new QueueClientBuilder()
.connectionString(connectStr)
.queueName(queueName)
.buildClient();
// Peek at the first message
PeekedMessageItem peekedMessageItem = queueClient.peekMessage();
System.out.println("Peeked message: " + peekedMessageItem.getMessageText());
}
catch (QueueStorageException e)
{
// Output the exception message and stack trace
System.out.println(e.getMessage());
e.printStackTrace();
}
}
Hoe te: De inhoud van een wachtrijbericht wijzigen
U kunt de inhoud van een bericht ter plaatse in de wachtrij wijzigen. Als het bericht een werktaak vertegenwoordigt, kunt u deze functie gebruiken om de status bij te werken. Met de volgende code wordt een wachtrijbericht bijgewerkt met nieuwe inhoud en wordt de time-out voor zichtbaarheid ingesteld om nog eens 30 seconden uit te breiden. Het uitbreiden van de zichtbaarheidstime-out geeft de client nog eens 30 seconden de tijd om door te gaan met het werken aan het bericht. U kunt ook een pogingenteller bijhouden. Als het bericht meer dan n keer opnieuw geprobeerd wordt, moet het worden verwijderd. Dit scenario beschermt tegen een bericht dat een toepassingsfout activeert telkens wanneer deze wordt verwerkt.
Het volgende codevoorbeeld doorzoekt de wachtrij met berichten, zoekt de eerste berichtinhoud die overeenkomt met een zoekreeks, wijzigt de inhoud van het bericht en sluit af.
public static void updateQueueMessage
(String connectStr, String queueName,
String searchString, String updatedContents)
{
try
{
// Instantiate a QueueClient which will be
// used to create and manipulate the queue
QueueClient queueClient = new QueueClientBuilder()
.connectionString(connectStr)
.queueName(queueName)
.buildClient();
// The maximum number of messages to retrieve is 32
final int MAX_MESSAGES = 32;
// Iterate through the queue messages
for (QueueMessageItem message : queueClient.receiveMessages(MAX_MESSAGES))
{
// Check for a specific string
if (message.getMessageText().equals(searchString))
{
// Update the message to be visible in 30 seconds
queueClient.updateMessage(message.getMessageId(),
message.getPopReceipt(),
updatedContents,
Duration.ofSeconds(30));
System.out.println(
String.format("Found message: \'%s\' and updated it to \'%s\'",
searchString,
updatedContents)
);
break;
}
}
}
catch (QueueStorageException e)
{
// Output the exception message and stack trace
System.out.println(e.getMessage());
e.printStackTrace();
}
}
In het volgende codevoorbeeld wordt alleen het eerste zichtbare bericht in de wachtrij bijgewerkt.
public static void updateFirstQueueMessage
(String connectStr, String queueName, String updatedContents)
{
try
{
// Instantiate a QueueClient which will be
// used to create and manipulate the queue
QueueClient queueClient = new QueueClientBuilder()
.connectionString(connectStr)
.queueName(queueName)
.buildClient();
// Get the first queue message
QueueMessageItem message = queueClient.receiveMessage();
// Check for a specific string
if (null != message)
{
// Update the message to be visible in 30 seconds
UpdateMessageResult result = queueClient.updateMessage(message.getMessageId(),
message.getPopReceipt(),
updatedContents,
Duration.ofSeconds(30));
System.out.println("Updated the first message with the receipt: " +
result.getPopReceipt());
}
}
catch (QueueStorageException e)
{
// Output the exception message and stack trace
System.out.println(e.getMessage());
e.printStackTrace();
}
}
Hoe de lengte van de wachtrij ophalen
U kunt een schatting krijgen van het aantal berichten in een wachtrij.
De methode getProperties retourneert verschillende waarden, waaronder het aantal berichten dat zich momenteel in een wachtrij bevindt. Het aantal is alleen bij benadering omdat berichten na uw aanvraag kunnen worden toegevoegd of verwijderd. De methode getApproximateMessageCount retourneert de laatste waarde die is opgehaald door de aanroep naar getProperties, zonder Queue Storage aan te roepen.
public static void getQueueLength(String connectStr, String queueName)
{
try
{
// Instantiate a QueueClient which will be
// used to create and manipulate the queue
QueueClient queueClient = new QueueClientBuilder()
.connectionString(connectStr)
.queueName(queueName)
.buildClient();
QueueProperties properties = queueClient.getProperties();
long messageCount = properties.getApproximateMessagesCount();
System.out.println(String.format("Queue length: %d", messageCount));
}
catch (QueueStorageException e)
{
// Output the exception message and stack trace
System.out.println(e.getMessage());
e.printStackTrace();
}
}
Hoe te: Het volgende bericht uit de wachtrij verwijderen
Uw code verwijdert in twee stappen een bericht uit een wachtrij. Wanneer u receiveMessagebelt, krijgt u het volgende bericht in een wachtrij. Een bericht dat wordt geretourneerd vanuit receiveMessage wordt onzichtbaar voor andere code die berichten uit deze wachtrij leest. Dit bericht blijft standaard 30 seconden onzichtbaar. Als u het bericht uit de wachtrij wilt verwijderen, moet u ook deleteMessageaanroepen. Als uw code een bericht niet kan verwerken, zorgt dit proces in twee stappen ervoor dat u hetzelfde bericht kunt krijgen en het opnieuw kunt proberen. Uw code roept deleteMessage direct nadat het bericht is verwerkt.
public static void dequeueMessage(String connectStr, String queueName)
{
try
{
// Instantiate a QueueClient which will be
// used to create and manipulate the queue
QueueClient queueClient = new QueueClientBuilder()
.connectionString(connectStr)
.queueName(queueName)
.buildClient();
// Get the first queue message
QueueMessageItem message = queueClient.receiveMessage();
// Check for a specific string
if (null != message)
{
System.out.println("Dequeing message: " + message.getMessageText());
// Delete the message
queueClient.deleteMessage(message.getMessageId(), message.getPopReceipt());
}
else
{
System.out.println("No visible messages in queue");
}
}
catch (QueueStorageException e)
{
// Output the exception message and stack trace
System.out.println(e.getMessage());
e.printStackTrace();
}
}
Aanvullende opties voor het uit de wachtrij halen van berichten
Er zijn twee manieren om het ophalen van berichten vanuit een wachtrij aan te passen. Haal eerst een batch berichten op (maximaal 32). Stel ten tweede een langere of kortere time-out voor onzichtbaarheid in, zodat uw code meer of minder tijd heeft om elk bericht volledig te verwerken.
In het volgende codevoorbeeld wordt de methode receiveMessages gebruikt om 20 berichten in één aanroep op te halen. Vervolgens wordt elk bericht verwerkt met behulp van een for lus. Ook wordt de time-out voor onzichtbaarheid ingesteld op vijf minuten (300 seconden) voor elk bericht. De time-out begint voor alle berichten tegelijk. Wanneer vijf minuten zijn verstreken sinds de aanroep naar receiveMessages, worden alle berichten die niet worden verwijderd, weer zichtbaar.
public static void dequeueMessages(String connectStr, String queueName)
{
try
{
// Instantiate a QueueClient which will be
// used to create and manipulate the queue
QueueClient queueClient = new QueueClientBuilder()
.connectionString(connectStr)
.queueName(queueName)
.buildClient();
// The maximum number of messages to retrieve is 20
final int MAX_MESSAGES = 20;
// Retrieve 20 messages from the queue with a
// visibility timeout of 300 seconds (5 minutes)
for (QueueMessageItem message : queueClient.receiveMessages(MAX_MESSAGES,
Duration.ofSeconds(300), Duration.ofSeconds(1), new Context("key1", "value1")))
{
// Do processing for all messages in less than 5 minutes,
// deleting each message after processing.
System.out.println("Dequeing message: " + message.getMessageText());
queueClient.deleteMessage(message.getMessageId(), message.getPopReceipt());
}
}
catch (QueueStorageException e)
{
// Output the exception message and stack trace
System.out.println(e.getMessage());
e.printStackTrace();
}
}
Hoe de wachtrijen weer te geven
Als u een lijst met de huidige wachtrijen wilt ophalen, roept u de QueueServiceClient.listQueues() methode aan, waarmee een verzameling QueueItem objecten wordt geretourneerd.
public static void listQueues(String connectStr)
{
try
{
// Instantiate a QueueServiceClient which will be
// used to list the queues
QueueServiceClient queueServiceClient = new QueueServiceClientBuilder()
.connectionString(connectStr)
.buildClient();
// Loop through the collection of queues.
for (QueueItem queue : queueServiceClient.listQueues())
{
// Output each queue name.
System.out.println(queue.getName());
}
}
catch (QueueStorageException e)
{
// Output the exception message and stack trace
System.out.println(e.getMessage());
e.printStackTrace();
}
}
Hoe: Een wachtrij verwijderen
Als u een wachtrij en alle berichten in de wachtrij wilt verwijderen, roept u de methode delete aan voor het QueueClient-object.
public static void deleteMessageQueue(String connectStr, String queueName)
{
try
{
// Instantiate a QueueClient which will be
// used to create and manipulate the queue
QueueClient queueClient = new QueueClientBuilder()
.connectionString(connectStr)
.queueName(queueName)
.buildClient();
System.out.println("Deleting queue: " + queueClient.getQueueName());
// Delete the queue
queueClient.delete();
}
catch (QueueStorageException e)
{
// Output the exception message and stack trace
System.out.println(e.getMessage());
e.printStackTrace();
}
}
Hint
Bekijk de opslagplaats met codevoorbeelden van Azure Storage
Raadpleeg onze lijst met Azure Storage-voorbeelden voor eenvoudig te gebruiken end-to-end Azure Storage-codevoorbeelden die u kunt downloaden en uitvoeren.
Volgende stappen
Nu u de basisprincipes van Queue Storage hebt geleerd, volgt u deze koppelingen voor meer informatie over complexere opslagtaken.
- Azure Storage SDK voor Java
- azure Storage-client-SDK-referentiemateriaal
- REST API voor Azure Storage-services
- Azure Storage-teamblog
Zie Codevoorbeelden met Java-versie 8 voor gerelateerde codevoorbeelden met verouderde Java versie 8 SDKs.