Queue Storage gebruiken vanuit Java
Overzicht
In deze handleiding ziet u hoe u code kunt maken voor veelvoorkomende scenario's met behulp van de Azure Queue Storage service. De voorbeelden zijn geschreven in Java en maken gebruik van de Azure Storage SDK voor Java. Scenario's omvatten het invoegen, bekijken, ontvangen en verwijderen van wachtrijberichten. Code voor het maken en verwijderen van wachtrijen wordt ook behandeld. Zie de sectie Volgende stappen voor meer informatie over wachtrijen.
Wat is Queue Storage?
Azure Queue Storage is een service voor de opslag van grote aantallen berichten die via HTTP of HTTPS overal vandaan kunnen worden opgevraagd met geverifieerde aanroepen. Een enkel wachtrijbericht mag maximaal 64 KB groot zijn en een wachtrij kan miljoenen berichten bevatten, tot de totale capaciteitslimiet van een opslagaccount. Queue Storage wordt vaak gebruikt om een achterstand te maken voor het asynchroon verwerken van werk.
Concepten van Queue-service
De Azure Queue-service bevat de volgende onderdelen:
Opslag account: Alle toegang tot Azure Storage wordt uitgevoerd via een opslag account. 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. Een bericht kan maximaal 7 dagen in de wachtrij blijven staan. 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: Wacht rijen zijn adresseerbaar met behulp van de volgende URL-indeling: http://
<storage account>. Queue.core.Windows.net/<queue>Met de volgende URL wordt een wachtrij in het diagram opgevraagd:
http://myaccount.queue.core.windows.net/incoming-orders
Een Azure-opslagaccount maken
De eenvoudigste manier om uw eerste Azure-opslag account 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 Resource Provider voor .NET.
Als u op dit moment liever geen opslag account maakt in azure, kunt u ook de Azurite-opslag emulator gebruiken om uw code uit te voeren en te testen in een lokale omgeving. Zie voor meer informatie de Azurite-emulator gebruiken voor het ontwikkelen van lokale Azure Storage.
Een Java-toepassing maken
Controleer eerst of uw ontwikkelsysteem voldoet aan de vereisten die worden vermeld in Azure Queue Storage clientbibliotheek v12 voor Java.
Maak een Java-toepassing met de naam queues-how-to-v12 :
Gebruik in een consolevenster (zoals cmd, PowerShell of Bash) Maven om een nieuwe console-app te maken met de naam
queues-how-to-v12. Typ de volgendemvn-opdracht om een Hallo wereld!-project in Java 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 map
queues-howto-v12.cd queues-howto-v12
Het pakket installeren
Open het bestand pom.xml in uw 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 boven aan het Java-bestand de volgende importin instructies toe waar u toegang wilt krijgen tot Azure Storage-API's:
// 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 gebruikt een connection string voor toegang tot gegevensbeheerservices. Haal de naam en de primaire toegangssleutel voor uw opslagaccount op die worden vermeld in Azure Portal. Gebruik ze als de AccountName waarden en in de AccountKey connection string. 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 uitgenomen dat String u een -object hebt met de connection string.
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;
}
}
Hoe: Een bericht toevoegen aan een wachtrij
Als u een bericht wilt invoegen in een bestaande wachtrij, roept u de methode sendMessage aan. Een bericht kan een tekenreeks (in UTF-8-indeling) of een byte-matrix zijn. Dit is de code die een tekenreeksbericht naar de wachtrij verzendt.
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();
}
}
How to: Peek at the next message (Het volgende bericht bekijken)
U kunt het bericht vooraan in een wachtrij bekijken zonder het uit de wachtrij te verwijderen door aan te peekMessage 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: de inhoud van een bericht in de wachtrij wijzigen
U kunt de inhoud van een bericht in de wachtrij wijzigen. Als het bericht een werktaak vertegenwoordigt, kunt u deze functie gebruiken om de status bij te werken. De volgende code werkt een wachtrijbericht bij met nieuwe inhoud en stelt de time-out voor zichtbaarheid in om nog eens 30 seconden uit te breiden. Door de time-out voor zichtbaarheid uit te breiden, krijgt de client nog eens 30 seconden om aan het bericht te blijven werken. U kunt ook het aantal nieuwe proberen behouden. Als het bericht meer dan n keer opnieuw wordt gedaan, verwijdert u het. Dit scenario beschermt tegen een bericht dat een toepassingsfout activeert telkens als het wordt verwerkt.
Het volgende codevoorbeeld zoekt in de wachtrij met berichten, zoekt de inhoud van het eerste bericht dat overeenkomt met een zoekreeks, wijzigt de berichtinhoud 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();
}
}
Met 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 op te halen
U kunt een schatting ophalen van het aantal berichten in de wachtrij.
De getProperties methode retourneert verschillende waarden, waaronder het aantal berichten dat zich momenteel in een wachtrij voordeed. Het aantal is slechts een schatting omdat berichten na uw aanvraag kunnen worden toegevoegd of verwijderd. De getApproximateMessageCount methode retourneert de laatste waarde die is opgehaald door de aanroep van getProperties , zonder Queue Storage.
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();
}
}
How to: Het volgende bericht uit dequequen
Met uw code wordt in twee stappen een bericht uit een wachtrij verwijderd. Wanneer u receiveMessage aanroept, krijgt u het volgende bericht in een wachtrij. Een bericht dat wordt geretourneerd receiveMessage door wordt onzichtbaar voor alle andere code die berichten uit deze wachtrij leest. Standaard blijft het bericht onzichtbaar gedurende 30 seconden. Als u het bericht uit de wachtrij wilt verwijderen, moet u ook deleteMessage aanroepen. Als uw code een bericht niet kan verwerken, zorgt dit proces in twee stappen ervoor dat u hetzelfde bericht kunt ontvangen en het opnieuw kunt proberen. Uw code roept aan 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 dequequeneren van berichten
Er zijn twee manieren om het ophalen van berichten uit 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 receiveMessages methode 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 voor elk bericht op vijf minuten (300 seconden) weergegeven. De time-out start voor alle berichten tegelijk. Wanneer er vijf minuten zijn verstreken sinds de aanroep van , worden berichten receiveMessages die niet zijn 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 in een lijst zetten
Als u een lijst met de huidige wachtrijen wilt ophalen, roept u de methode QueueServiceClient.listQueues() aan. Deze retourneert een verzameling QueueItem objecten.
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();
}
}
Een wachtrij verwijderen
Als u een wachtrij en alle berichten erin wilt verwijderen, roept u de delete -methode op het QueueClient -object aan.
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();
}
}
Tip
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 basisbeginselen van Queue Storage hebt geleerd, volgt u deze koppelingen voor meer informatie over complexere opslagtaken.