Come usare gli argomenti e le sottoscrizioni del bus di servizio con JavaHow to use Service Bus topics and subscriptions with Java

Questa guida descrive come usare gli argomenti e le sottoscrizioni del bus di servizio.This guide describes how to use Service Bus topics and subscriptions. Gli esempi sono scritti in Java e usano Azure SDK per Java.The samples are written in Java and use the Azure SDK for Java. Gli scenari presentati includono la creazione di argomenti e sottoscrizioni, la creazione di filtri per le sottoscrizioni, l’invio di messaggi a un argomento, la ricezione di messaggi da una sottoscrizione e l’eliminazione di argomenti e sottoscrizioni.The scenarios covered include creating topics and subscriptions, creating subscription filters, sending messages to a topic, receiving messages from a subscription, and deleting topics and subscriptions.

Cosa sono gli argomenti e le sottoscrizioni del bus di servizio?What are Service Bus topics and subscriptions?

Gli argomenti e le sottoscrizioni del bus di servizio supportano un modello di comunicazione con messaggistica di pubblicazione-sottoscrizione .Service Bus topics and subscriptions support a publish/subscribe messaging communication model. Quando si usano gli argomenti e le sottoscrizioni, i componenti di un'applicazione distribuita non comunicano direttamente l'uno con l'altro, ma scambiano messaggi tramite un argomento, che agisce da intermediario.When using topics and subscriptions, components of a distributed application do not communicate directly with each other; instead they exchange messages via a topic, which acts as an intermediary.

Concetti relativi agli argomenti

Diversamente dalle code del bus di servizio, in cui ogni messaggio viene elaborato da un unico consumer, gli argomenti e le sottoscrizioni offrono una forma di comunicazione "uno a molti" tramite un modello di pubblicazione-sottoscrizione.In contrast with Service Bus queues, in which each message is processed by a single consumer, topics and subscriptions provide a "one-to-many" form of communication, using a publish/subscribe pattern. È possibile registrare più sottoscrizioni a un argomento.It is possible to register multiple subscriptions to a topic. Quando un messaggio viene inviato a un argomento, viene reso disponibile affinché ogni sottoscrizione possa gestirlo o elaborarlo in modo indipendente.When a message is sent to a topic, it is then made available to each subscription to handle/process independently.

La sottoscrizione a un argomento è simile a una coda virtuale che riceve copie dei messaggi che sono stati inviati all'argomento.A subscription to a topic resembles a virtual queue that receives copies of the messages that were sent to the topic. È possibile registrare regole di filtro per un argomento in base alla sottoscrizione in modo da poter filtrare/limitare i messaggi a un argomento ricevuti dalle diverse sottoscrizioni degli argomenti.You can optionally register filter rules for a topic on a per-subscription basis, which allows you to filter/restrict which messages to a topic are received by which topic subscriptions.

Gli argomenti e le sottoscrizioni del bus di servizio consentono scalabilità per elaborare grandi quantità di messaggi tra un numero elevato di utenti e applicazioni.Service Bus topics and subscriptions enable you to scale to process a large number of messages across a large number of users and applications.

Creare uno spazio dei nomi del servizioCreate a service namespace

Per iniziare a usare gli argomenti e le sottoscrizioni del bus di servizio in Azure, è prima di tutto necessario creare uno spazio dei nomi che fornisce un contenitore di ambito per fare riferimento alle risorse del bus di servizio all'interno dell'applicazione.To begin using Service Bus topics and subscriptions in Azure, you must first create a namespace, which provides a scoping container for addressing Service Bus resources within your application.

Per creare uno spazio dei nomi:To create a namespace:

Per iniziare a usare le entità di messaggistica del bus di servizio in Azure, prima di tutto è necessario creare uno spazio dei nomi con un nome univoco in Azure.To begin using Service Bus messaging entities in Azure, you must first create a namespace with a name that is unique across Azure. Uno spazio dei nomi fornisce un contenitore di ambito per fare riferimento alle risorse del bus di servizio all'interno dell'applicazione.A namespace provides a scoping container for addressing Service Bus resources within your application.

Per creare uno spazio dei nomi:To create a namespace:

  1. Accedere al portale di Azure.Log on to the Azure portal.
  2. Nel riquadro di spostamento sinistro del portale fare clic su Nuovo, quindi su Enterprise Integration e infine su Bus di servizio.In the left navigation pane of the portal, click New, then click Enterprise Integration, and then click Service Bus.
  3. Nella finestra di dialogo Crea spazio dei nomi immettere un nome per lo spazio dei nomi.In the Create namespace dialog, enter a namespace name. Verrà effettuato immediatamente un controllo sulla disponibilità del nome.The system immediately checks to see if the name is available.
  4. Dopo aver verificato che il nome dello spazio dei nomi sia disponibile, scegliere il piano tariffario, ovvero Basic, Standard o Premium.After making sure the namespace name is available, choose the pricing tier (Basic, Standard, or Premium).
  5. Nel campo Sottoscrizione scegliere una sottoscrizione di Azure in cui creare lo spazio dei nomi.In the Subscription field, choose an Azure subscription in which to create the namespace.
  6. Nel campo Gruppo di risorse scegliere un gruppo di risorse esistente nel quale risiederà lo spazio dei nomi oppure crearne uno nuovo.In the Resource group field, choose an existing resource group in which the namespace will live, or create a new one.
  7. In Localitàscegliere il paese o l'area in cui deve essere ospitato lo spazio dei nomi.In Location, choose the country or region in which your namespace should be hosted.

    Crea spazio dei nomi

  8. Fare clic su Crea.Click Create. A questo punto, lo spazio dei nomi verrà creato e abilitato nel sistema.The system now creates your namespace and enables it. Potrebbero essere necessari alcuni minuti per consentire al sistema di effettuare il provisioning delle risorse per lo spazio dei nomi creato.You might have to wait several minutes as the system provisions resources for your account.

Ottenere le credenziali di gestioneObtain the management credentials

Con la creazione di un nuovo spazio dei nomi verrà generata automaticamente una regola di firma di accesso condiviso iniziale con una coppia di chiavi primaria e secondaria associata che concede il controllo completo di tutti gli aspetti dello spazio dei nomi.Creating a new namespace will automatically generate an initial Shared Access Signature (SAS) rule with an associated pair of primary and secondary keys that grants full control over all aspects of the namespace. Vedere Autenticazione e autorizzazione del bus di servizio per informazioni su come creare altre regole con diritti più limitati per mittenti e destinatari normali.Refer to Service Bus authentication and authorization for how to create further rules with more constrained rights for regular senders and receivers. Per copiare la regola iniziale seguire questa procedura:To copy the initial rule, follow these steps:

  1. Nell'elenco degli spazi dei nomi fare clic sul nome dello spazio dei nomi appena creato.In the list of namespaces, click the newly created namespace name.
  2. Nel pannello dello spazio dei nomi fare clic su Criteri di accesso condivisi.In the namespace blade, click Shared access policies.
  3. Nel pannello Criteri di accesso condivisi fare clic su RootManageSharedAccessKey.In the Shared access policies blade, click RootManageSharedAccessKey.

    connection-info

  4. Nel pannello Criteri: RootManageSharedAccessKey fare clic sul pulsante Copia accanto a Stringa di connessione - chiave primaria per copiare la stringa di connessione negli Appunti e usarla in un secondo momento.In the Policy: RootManageSharedAccessKey blade, click the copy button next to Connection string–primary key, to copy the connection string to your clipboard for later use. Incollare questo valore nel Blocco note o in un'altra posizione temporanea.Paste this value into Notepad or some other temporary location.

    connection-string

  5. Ripetere il passaggio precedente e copiare e incollare il valore della chiave primaria in un percorso temporaneo per usarlo in seguito.Repeat the previous step, copying and pasting the value of Primary key to a temporary location for later use.

Configurare l'applicazione per l'uso del bus di servizioConfigure your application to use Service Bus

Assicurarsi di aver installato Azure SDK per Java prima di compilare questo esempio.Make sure you have installed the Azure SDK for Java before building this sample. Se si usa Eclipse, è possibile installare Azure Toolkit for Eclipse che include Azure SDK per Java.If you are using Eclipse, you can install the Azure Toolkit for Eclipse that includes the Azure SDK for Java. È quindi possibile aggiungere le librerie di Microsoft Azure per Java al progetto:You can then add the Microsoft Azure Libraries for Java to your project:

Aggiungere le seguenti istruzioni import all'inizio del file Java:Add the following import statements to the top of the Java file:

import com.microsoft.windowsazure.services.servicebus.*;
import com.microsoft.windowsazure.services.servicebus.models.*;
import com.microsoft.windowsazure.core.*;
import javax.xml.datatype.*;

Aggiungere le librerie di Azure per Java al percorso di compilazione e includerlo nell'assembly di distribuzione del progetto.Add the Azure Libraries for Java to your build path and include it in your project deployment assembly.

Creare un argomentoCreate a topic

Per eseguire operazioni di gestione per gli argomenti del bus di servizio, è possibile usare la classe ServiceBusContract.Management operations for Service Bus topics can be performed via the ServiceBusContract class. Un oggetto ServiceBusContract è costruito con una configurazione appropriata che incapsula il token di firma di accesso condiviso con le autorizzazioni necessarie a gestirlo. La classe ServiceBusContract rappresenta l'unico punto di comunicazione con Azure.A ServiceBusContract object is constructed with an appropriate configuration that encapsulates the SAS token with permissions to manage it, and the ServiceBusContract class is the sole point of communication with Azure.

La classe ServiceBusService definisce i metodi per creare, enumerare ed eliminare gli argomenti.The ServiceBusService class provides methods to create, enumerate, and delete topics. L'esempio seguente illustra come usare un oggetto ServiceBusService per creare un argomento con il nome TestTopic e uno spazio dei nomi denominato HowToSample:The following example shows how a ServiceBusService object can be used to create a topic named TestTopic, with a namespace called HowToSample:

Configuration config =
    ServiceBusConfiguration.configureWithSASAuthentication(
      "HowToSample",
      "RootManageSharedAccessKey",
      "SAS_key_value",
      ".servicebus.windows.net"
      );

ServiceBusContract service = ServiceBusService.create(config);
TopicInfo topicInfo = new TopicInfo("TestTopic");
try  
{
    CreateTopicResult result = service.createTopic(topicInfo);
}
catch (ServiceException e) {
    System.out.print("ServiceException encountered: ");
    System.out.println(e.getMessage());
    System.exit(-1);
}

In TopicInfo sono disponibili metodi che consentono di impostare le proprietà dell'argomento, ad esempio il valore TTL predefinito da applicare ai messaggi inviati all'argomento.There are methods on TopicInfo that enable properties of the topic to be set (for example: to set the default time-to-live (TTL) value to be applied to messages sent to the topic). L'esempio seguente illustra come creare un argomento denominato TestTopic con una dimensione massima pari a 5 GB:The following example shows how to create a topic named TestTopic with a maximum size of 5 GB:

long maxSizeInMegabytes = 5120;  
TopicInfo topicInfo = new TopicInfo("TestTopic");  
topicInfo.setMaxSizeInMegabytes(maxSizeInMegabytes);
CreateTopicResult result = service.createTopic(topicInfo);

È possibile usare il metodo listTopics sugli oggetti ServiceBusContract per verificare se un argomento con il nome specificato è già presente nello spazio dei nomi di un servizio.You can use the listTopics method on ServiceBusContract objects to check if a topic with a specified name already exists within a service namespace.

Creare sottoscrizioniCreate subscriptions

È possibile creare le sottoscrizioni a un argomento anche tramite la classe ServiceBusService.Subscriptions to topics are also created with the ServiceBusService class. Le sottoscrizioni sono denominate e possono includere un filtro facoltativo che limita l'insieme dei messaggi passati alla coda virtuale della sottoscrizione.Subscriptions are named and can have an optional filter that restricts the set of messages passed to the subscription's virtual queue.

Creare una sottoscrizione con il filtro (MatchAll) predefinitoCreate a subscription with the default (MatchAll) filter

Se non vengono specificati altri filtri durante la creazione di una nuova sottoscrizione, viene usato il filtro predefinito MatchAll.If no filter is specified when a new subscription is created, the MatchAll filter is the default filter that is used. Quando si usa il filtro MatchAll, tutti i messaggi pubblicati nell'argomento vengono inseriti nella coda virtuale della sottoscrizione.When the MatchAll filter is used, all messages published to the topic are placed in the subscription's virtual queue. Nell'esempio seguente viene creata una sottoscrizione denominata "AllMessages" e viene usato il filtro MatchAll predefinito.The following example creates a subscription named "AllMessages" and uses the default MatchAll filter.

SubscriptionInfo subInfo = new SubscriptionInfo("AllMessages");
CreateSubscriptionResult result =
    service.createSubscription("TestTopic", subInfo);

Creare sottoscrizioni con i filtriCreate subscriptions with filters

È anche possibile creare filtri che consentono di specificare i messaggi inviati a un argomento da visualizzare in una specifica sottoscrizione dell'argomento.You can also create filters that enable you to scope which messages sent to a topic should show up within a specific topic subscription.

Il tipo di filtro più flessibile tra quelli supportati dalle sottoscrizioni è SqlFilter, che implementa un subset di SQL92.The most flexible type of filter supported by subscriptions is the SqlFilter, which implements a subset of SQL92. I filtri SQL agiscono sulle proprietà dei messaggi pubblicati nell'argomento.SQL filters operate on the properties of the messages that are published to the topic. Per altri dettagli sulle espressioni che è possibile usare con un filtro SQL, esaminare la sintassi di SqlFilter.SqlExpression.For more details about the expressions that can be used with a SQL filter, review the SqlFilter.SqlExpression syntax.

L'esempio seguente crea una sottoscrizione denominata HighMessages con un oggetto SqlFilter che seleziona solo i messaggi che hanno una proprietà MessageNumber personalizzata maggiore di 3:The following example creates a subscription named HighMessages with a SqlFilter object that only selects messages that have a custom MessageNumber property greater than 3:

// Create a "HighMessages" filtered subscription  
SubscriptionInfo subInfo = new SubscriptionInfo("HighMessages");
CreateSubscriptionResult result = service.createSubscription("TestTopic", subInfo);
RuleInfo ruleInfo = new RuleInfo("myRuleGT3");
ruleInfo = ruleInfo.withSqlExpressionFilter("MessageNumber > 3");
CreateRuleResult ruleResult = service.createRule("TestTopic", "HighMessages", ruleInfo);
// Delete the default rule, otherwise the new rule won't be invoked.
service.deleteRule("TestTopic", "HighMessages", "$Default");

Analogamente, l'esempio seguente crea una sottoscrizione denominata LowMessages con un oggetto SqlFilter che seleziona solo i messaggi in cui il valore della proprietà MessageNumber è minore o uguale a 3:Similarly, the following example creates a subscription named LowMessages with a SqlFilter object that only selects messages that have a MessageNumber property less than or equal to 3:

// Create a "LowMessages" filtered subscription
SubscriptionInfo subInfo = new SubscriptionInfo("LowMessages");
CreateSubscriptionResult result = service.createSubscription("TestTopic", subInfo);
RuleInfo ruleInfo = new RuleInfo("myRuleLE3");
ruleInfo = ruleInfo.withSqlExpressionFilter("MessageNumber <= 3");
CreateRuleResult ruleResult = service.createRule("TestTopic", "LowMessages", ruleInfo);
// Delete the default rule, otherwise the new rule won't be invoked.
service.deleteRule("TestTopic", "LowMessages", "$Default");

Un messaggio inviato a TestTopic viene sempre recapitato a destinatari con sottoscrizione a AllMessages e recapitato selettivamente a destinatari con sottoscrizioni a HighMessages e LowMessages (a seconda del contenuto del messaggio).When a message is now sent to TestTopic, it is always delivered to receivers subscribed to the AllMessages subscription, and selectively delivered to receivers subscribed to the HighMessages and LowMessages subscriptions (depending upon the message content).

Inviare messaggi a un argomentoSend messages to a topic

Per inviare un messaggio a un argomento del bus di servizio, l'applicazione ottiene un oggetto ServiceBusContract.To send a message to a Service Bus topic, your application obtains a ServiceBusContract object. Il codice seguente illustra come inviare un messaggio all'argomento TestTopic creato in precedenza nello spazio dei nomi HowToSample:The following code demonstrates how to send a message for the TestTopic topic created previously within the HowToSample namespace:

BrokeredMessage message = new BrokeredMessage("MyMessage");
service.sendTopicMessage("TestTopic", message);

I messaggi inviati ad argomenti del bus di servizio sono istanze della classe BrokeredMessage.Messages sent to Service Bus Topics are instances of the BrokeredMessage class. Gli oggetti BrokeredMessage* includono un set di metodi standard, ad esempio setLabel e TimeToLive, un dizionario usato per contenere le proprietà personalizzate specifiche dell'applicazione e un corpo di dati arbitrari dell'applicazione.BrokeredMessage* objects have a set of standard methods (such as setLabel and TimeToLive), a dictionary that is used to hold custom application-specific properties, and a body of arbitrary application data. Un'applicazione può impostare il corpo del messaggio passando un oggetto serializzabile al costruttore di BrokeredMessage e l'elemento DataContractSerializer appropriato viene quindi usato per serializzare l'oggetto.An application can set the body of the message by passing any serializable object into the constructor of the BrokeredMessage, and the appropriate DataContractSerializer is then used to serialize the object. In alternativa, è possibile specificare un oggetto java.io.InputStream.Alternatively, a java.io.InputStream can be provided.

L'esempio seguente illustra come inviare cinque messaggi di test all'oggetto TestTopic MessageSender ottenuto nel frammento di codice precedente.The following example demonstrates how to send five test messages to the TestTopic MessageSender we obtained in the previous code snippet. Si noti come il valore della proprietà MessageNumber di ogni messaggio varia nell'iterazione del ciclo, determinando le sottoscrizioni che lo ricevono:Note how the MessageNumber property value of each message varies on the iteration of the loop (this value determines which subscriptions receive it):

for (int i=0; i<5; i++)  {
// Create message, passing a string message for the body
BrokeredMessage message = new BrokeredMessage("Test message " + i);
// Set some additional custom app-specific property
message.setProperty("MessageNumber", i);
// Send message to the topic
service.sendTopicMessage("TestTopic", message);
}

Gli argomenti del bus di servizio supportano messaggi di dimensioni massime fino a 256 KB nel livello Standard e fino a 1 MB nel livello Premium.Service Bus topics support a maximum message size of 256 KB in the Standard tier and 1 MB in the Premium tier. Le dimensioni massime dell'intestazione, che include le proprietà standard e personalizzate dell'applicazione, non possono superare 64 KB.The header, which includes the standard and custom application properties, can have a maximum size of 64 KB. Non esiste alcun limite al numero di messaggi mantenuti in un argomento, mentre è previsto un limite alla dimensione totale dei messaggi di un argomento.There is no limit on the number of messages held in a topic but there is a limit on the total size of the messages held by a topic. Questa dimensione dell'argomento viene definita al momento della creazione, con un limite massimo di 5 GB.This topic size is defined at creation time, with an upper limit of 5 GB.

Come ricevere messaggi da una sottoscrizioneHow to receive messages from a subscription

Per ricevere i messaggi da una sottoscrizione, usare un oggetto ServiceBusContract.To receive messages from a subscription, use a ServiceBusContract object. I messaggi ricevuti possono essere usati in due modalità diverse: ReceiveAndDelete e PeekLock (modalità predefinita).Received messages can work in two different modes: ReceiveAndDelete and PeekLock (the default).

Quando si usa la modalità ReceiveAndDelete, l'operazione di ricezione viene eseguita in un'unica fase. Quando infatti il bus di servizio riceve la richiesta di lettura relativa a un messaggio, lo contrassegna come usato e lo restituisce all'applicazione.When using the ReceiveAndDelete mode, receive is a single-shot operation - that is, when Service Bus receives a read request for a message, it marks the message as being consumed and returns it to the application. La modalità ReceiveAndDelete rappresenta il modello più semplice ed è adatta per scenari in cui un'applicazione può tollerare la mancata elaborazione di un messaggio in caso di errore.ReceiveAndDelete mode is the simplest model and works best for scenarios in which an application can tolerate not processing a message if a failure occurs. Si consideri, ad esempio, uno scenario in cui il consumer invia la richiesta di ricezione e quindi si arresta in modo anomalo prima dell'elaborazione.For example, consider a scenario in which the consumer issues the receive request and then crashes before processing it. Poiché il bus di servizio ha contrassegnato il messaggio come utilizzato, quando l'applicazione viene riavviata e inizia a usare nuovamente i messaggi, il messaggio usato prima dell'arresto anomalo del sistema risulta perso.Because Service Bus has marked the message as being consumed, then when the application restarts and begins consuming messages again, it has missed the message that was consumed prior to the crash.

Nella modalità PeekLock l'operazione di ricezione viene suddivisa in due fasi, in modo da consentire il supporto di applicazioni che non possono tollerare messaggi mancanti.In PeekLock mode, receive becomes a two stage operation, which makes it possible to support applications that cannot tolerate missing messages. Quando il bus di servizio riceve una richiesta, individua il messaggio successivo da usare, lo blocca per impedirne la ricezione da parte di altri consumer e quindi lo restituisce all'applicazione.When Service Bus receives a request, it finds the next message to be consumed, locks it to prevent other consumers receiving it, and then returns it to the application. Dopo aver elaborato il messaggio o averlo archiviato in modo affidabile per successive elaborazioni, l'applicazione esegue la seconda fase del processo di ricezione chiamando Delete sul messaggio ricevuto.After the application finishes processing the message (or stores it reliably for future processing), it completes the second stage of the receive process by calling Delete on the received message. Quando il bus di servizio vede la chiamata Delete, contrassegna il messaggio come usato e lo rimuove dall'argomento.When Service Bus sees the Delete call, it marks the message as being consumed and removes it from the topic.

Nell'esempio seguente viene illustrato come ricevere ed elaborare messaggi usando PeekLock (la modalità predefinita).The following example demonstrates how messages can be received and processed using PeekLock (the default mode). L'esempio esegue un ciclo, elabora i messaggi nella sottoscrizione HighMessages e viene chiuso quando non sono più presenti messaggi. In alternativa, l'esempio può essere impostato per attendere l'arrivo di nuovi messaggi.The example performs a loop and processes messages in the HighMessages subscription and then exits when there are no more messages (alternatively, it can be set to wait for new messages).

try
{
    ReceiveMessageOptions opts = ReceiveMessageOptions.DEFAULT;
    opts.setReceiveMode(ReceiveMode.PEEK_LOCK);

    while(true)  {
        ReceiveSubscriptionMessageResult  resultSubMsg =
            service.receiveSubscriptionMessage("TestTopic", "HighMessages", opts);
        BrokeredMessage message = resultSubMsg.getValue();
        if (message != null && message.getMessageId() != null)
        {
            System.out.println("MessageID: " + message.getMessageId());
            // Display the topic message.
            System.out.print("From topic: ");
            byte[] b = new byte[200];
            String s = null;
            int numRead = message.getBody().read(b);
            while (-1 != numRead)
            {
                s = new String(b);
                s = s.trim();
                System.out.print(s);
                numRead = message.getBody().read(b);
            }
            System.out.println();
            System.out.println("Custom Property: " +
                message.getProperty("MessageNumber"));
            // Delete message.
            System.out.println("Deleting this message.");
            service.deleteMessage(message);
        }  
        else  
        {
            System.out.println("Finishing up - no more messages.");
            break;
            // Added to handle no more messages.
            // Could instead wait for more messages to be added.
        }
    }
}
catch (ServiceException e) {
    System.out.print("ServiceException encountered: ");
    System.out.println(e.getMessage());
    System.exit(-1);
}
catch (Exception e) {
    System.out.print("Generic exception encountered: ");
    System.out.println(e.getMessage());
    System.exit(-1);
}

Come gestire arresti anomali e messaggi illeggibili dell'applicazioneHow to handle application crashes and unreadable messages

Il bus di servizio fornisce funzionalità per il ripristino gestito automaticamente in caso di errori nell'applicazione o di problemi di elaborazione di un messaggio.Service Bus provides functionality to help you gracefully recover from errors in your application or difficulties processing a message. Se un'applicazione ricevitore non è in grado di elaborare il messaggio per un qualsiasi motivo, può chiamare il metodo unlockMessage, anziché deleteMessage, per il messaggio ricevuto.If a receiver application is unable to process the message for some reason, then it can call the unlockMessage method on the received message (instead of the deleteMessage method). In questo modo, il bus di servizio sblocca il messaggio nell'argomento rendendolo nuovamente disponibile per la ricezione da parte della stessa applicazione consumer o di un'altra.This causes Service Bus to unlock the message within the topic and make it available to be received again, either by the same consuming application or by another consuming application.

Al messaggio bloccato nell'argomento è anche associato un timeout. Se l'applicazione non riesce a elaborare il messaggio prima della scadenza del timeout del blocco, ad esempio a causa di un arresto anomalo, il bus di servizio sbloccherà automaticamente il messaggio rendendolo nuovamente disponibile per la ricezione.There is also a timeout associated with a message locked within the topic, and if the application fails to process the message before the lock timeout expires (for example, if the application crashes), then Service Bus unlocks the message automatically and makes it available to be received again.

In caso di arresto anomalo dell'applicazione dopo l'elaborazione del messaggio ma prima dell'invio della richiesta deleteMessage, il messaggio viene nuovamente recapitato all'applicazione al riavvio.In the event that the application crashes after processing the message but before the deleteMessage request is issued, then the message is redelivered to the application when it restarts. Questo processo viene spesso definito di tipo At-Least-Once, per indicare che ogni messaggio verrà elaborato almeno una volta ma che in determinate situazioni potrà essere recapitato una seconda volta.This process is often called At Least Once Processing; that is, each message is processed at least once but in certain situations the same message may be redelivered. Se lo scenario non tollera la doppia elaborazione, gli sviluppatori dovranno aggiungere logica aggiuntiva all'applicazione per gestire il secondo recapito del messaggio.If the scenario cannot tolerate duplicate processing, then application developers should add additional logic to their application to handle duplicate message delivery. A tale scopo viene spesso usato il metodo getMessageId del messaggio, che rimane costante in tutti i tentativi di recapito.This is often achieved using the getMessageId method of the message, which remains constant across delivery attempts.

Eliminare argomenti e sottoscrizioniDelete topics and subscriptions

Per eliminare argomenti e sottoscrizioni si usa principalmente un oggetto ServiceBusContract.The primary way to delete topics and subscriptions is to use a ServiceBusContract object. Se si elimina un argomento, vengono eliminate anche tutte le sottoscrizioni registrate con l'argomento.Deleting a topic also deletes any subscriptions that are registered with the topic. Le sottoscrizioni possono essere eliminate anche in modo indipendente.Subscriptions can also be deleted independently.

// Delete subscriptions
service.deleteSubscription("TestTopic", "AllMessages");
service.deleteSubscription("TestTopic", "HighMessages");
service.deleteSubscription("TestTopic", "LowMessages");

// Delete a topic
service.deleteTopic("TestTopic");

Passaggi successiviNext Steps

A questo punto, dopo aver appreso le nozioni di base delle code del bus di servizio, per altre informazioni vedere Code, argomenti e sottoscrizioni del bus di servizio.Now that you've learned the basics of Service Bus queues, see Service Bus queues, topics, and subscriptions for more information.