Queue Storage gebruiken vanuit Java
Overzicht
In deze handleiding wordt uitgelegd hoe u code maakt 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 zijn onder andere het invoegen, bekijken, ophalen 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 van werk te maken om asynchroon te verwerken.
Concepten van Queue-service
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. 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: Wachtrijen kunnen worden adresseerbaar met 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-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 Resource Provider voor .NET.
Als u op dit moment liever geen opslagaccount in Azure maakt, kunt u de Azurite-opslagemulator ook gebruiken om uw code in een lokale omgeving uit te voeren en te testen. Zie Use the Azurite emulator for local Azure Storage development (De Azurite-emulator gebruiken voor lokale Azure Storage-ontwikkeling) voor 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 met de naam queues-how-to-v12maken:
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 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 gebruikt een opslag-connection string voor toegang tot gegevensbeheerservices. Haal de naam en de primaire toegangssleutel op voor uw opslagaccount die worden vermeld in de Azure Portal. Gebruik deze als de AccountName waarden en AccountKey in de 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 uitgegaan dat u een String object hebt met de opslag connection string.
Procedure: 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 aan sendMessage . 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: bekijk het volgende bericht
U kunt het bericht bekijken aan de voorzijde van een wachtrij zonder het uit de wachtrij te verwijderen door aan te roepen peekMessage.
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();
}
}
Procedure: 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. Met de volgende code wordt een wachtrijbericht bijgewerkt met nieuwe inhoud en wordt de time-out voor zichtbaarheid ingesteld om nog eens 30 seconden te verlengen. Door de time-out voor zichtbaarheid uit te breiden, krijgt de client nog 30 seconden de tijd om verder te werken aan het bericht. U kunt ook het aantal nieuwe pogingen bijhouden. Als het bericht meer dan n keer opnieuw wordt geprobeerd, verwijdert u het. 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 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();
}
}
Procedure: De lengte van de wachtrij ophalen
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 bevindt. Het aantal is alleen bij benadering omdat berichten kunnen worden toegevoegd of verwijderd na uw aanvraag. De getApproximateMessageCount methode retourneert de laatste waarde die is opgehaald door de aanroep naar , zonder Queue Storage aan te getPropertiesroepen.
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();
}
}
Procedure: Het volgende bericht uit de wachtrij verwijderen
Uw code verwijdert in twee stappen een bericht uit een wachtrij. Wanneer u aanroept receiveMessage, krijgt u het volgende bericht in een wachtrij. Een bericht dat wordt geretourneerd van receiveMessage wordt onzichtbaar voor andere code die berichten uit deze wachtrij leest. Standaard blijft het bericht onzichtbaar gedurende 30 seconden. Als u het verwijderen van het bericht uit de wachtrij wilt voltooien, moet u ook aanroepen deleteMessage. 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 zodra 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 verwijderen 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 vervolgens 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 ingesteld op vijf minuten (300 seconden) voor elk bericht. De time-out begint voor alle berichten tegelijk. Wanneer er vijf minuten zijn verstreken sinds de aanroep van receiveMessages, worden berichten 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();
}
}
Procedure: De wachtrijen weergeven
Als u een lijst met de huidige wachtrijen wilt ophalen, roept u de methode aan QueueServiceClient.listQueues() , die een verzameling QueueItem objecten retourneert.
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();
}
}
Procedure: Een wachtrij verwijderen
Als u een wachtrij en alle berichten in de wachtrij wilt verwijderen, roept u de delete methode aan op 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();
}
}
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.
- Azure Storage SDK voor Java
- Naslaginformatie over azure Storage-client-SDK
- REST API voor Azure Storage-services
- Azure Storage-teamblog
Zie Codevoorbeelden met Java versie 8 voor gerelateerde codevoorbeelden met behulp van afgeschafte Java versie 8 SDK's.