Rychlý start: Vytvořit frontu služby Service Bus pomocí Azure CLIQuickstart: Use the Azure CLI to create a Service Bus queue

Tento rychlý start popisuje způsob odesílání a příjem zpráv pomocí Service Bus pomocí Azure CLI a knihovny Service Bus v Javě.This quickstart describes how to send and receive messages with Service Bus by using the Azure CLI and the Service Bus Java library. Pokud vás zajímají techničtější podrobnosti, můžete si přečíst vysvětlení klíčových prvků vzorového kódu.Finally, if you're interested in more technical details, you can read an explanation of the key elements of the sample code.

Co jsou fronty služby Service Bus?What are Service Bus queues?

Fronty služby Service Bus podporují komunikační model zprostředkovaného zasílání zpráv.Service Bus queues support a brokered messaging communication model. Součásti distribuované aplikace při používání front nekomunikují navzájem přímo. Místo toho si zprávy vyměňují prostřednictvím fronty, která slouží jako zprostředkovatel.When using queues, components of a distributed application do not communicate directly with each other; instead they exchange messages via a queue, which acts as an intermediary (broker). Autor zprávy (odesílatel) předá zprávu do fronty a potom pokračuje v jejím zpracování.A message producer (sender) hands off a message to the queue and then continues its processing. Spotřebitel zprávy (příjemce) asynchronně přebírá zprávu z fronty a zpracovává ji.Asynchronously, a message consumer (receiver) pulls the message from the queue and processes it. Autor nemusí čekat na odpověď od příjemce, aby mohl pokračovat se zpracováním a odesláním dalších zpráv.The producer does not have to wait for a reply from the consumer in order to continue to process and send further messages. Fronty nabízejí doručování zpráv metodou FIFO (First In First Out) pro jednoho nebo několik konkurenčních spotřebitelů.Queues offer First In, First Out (FIFO) message delivery to one or more competing consumers. To znamená, že příjemci zprávy obvykle přijímají a zpracovávají v pořadí, ve kterém byly přidány do fronty, a každou zprávu přijme a zpracuje jenom jeden příjemce zprávy.That is, messages are typically received and processed by the receivers in the order in which they were added to the queue, and each message is received and processed by only one message consumer.

QueueConcepts

Fronty služby Service Bus představují univerzální technologii, kterou můžete použít pro celou řadu scénářů:Service Bus queues are a general-purpose technology that can be used for a wide variety of scenarios:

  • Komunikace mezi webovou rolí a rolí pracovního procesu ve vícevrstvé aplikaci Azure.Communication between web and worker roles in a multi-tier Azure application.
  • Komunikace mezi místními aplikacemi a aplikacemi hostovanými v Azure v případě hybridního řešení.Communication between on-premises apps and Azure-hosted apps in a hybrid solution.
  • Komunikace mezi součástmi distribuované aplikace spuštěné místně v různých organizacích nebo odděleních organizace.Communication between components of a distributed application running on-premises in different organizations or departments of an organization.

Použití fronty vám umožňuje snazší škálování aplikací a zvyšuje odolnost vaší architektury proti chybám.Using queues enables you to scale your applications more easily, and enable more resiliency to your architecture.

PožadavkyPrerequisites

Pokud nemáte předplatné Azure, můžete vytvořit [bezplatný účet] free account předtím, než začnete.If you don't have an Azure subscription, you can create a free account before you begin.

Použití služby Azure Cloud ShellUse Azure Cloud Shell

Hostitelé Azure Azure Cloud Shell interaktivní prostředí prostředí, které můžete používat v prohlížeči.Azure hosts Azure Cloud Shell, an interactive shell environment that you can use through your browser. Cloud Shell vám umožní pracovat se bash službami PowerShell Azure pomocí nebo.Cloud Shell lets you use either bash or PowerShell to work with Azure services. Můžete použít Cloud Shell předinstalované příkazy ke spuštění kódu v tomto článku, aniž byste museli instalovat cokoli do svého místního prostředí.You can use the Cloud Shell pre-installed commands to run the code in this article without having to install anything on your local environment.

Spuštění Azure Cloud Shell:To launch Azure Cloud Shell:

MožnostOption Příklad nebo propojeníExample/Link
Zvolte Vyzkoušet v pravém horním rohu bloku kódu.Select Try It in the upper-right corner of a code block. Při výběru možnosti vyzkoušet se kód automaticky nezkopíruje do Cloud Shell.Selecting Try It doesn't automatically copy the code to Cloud Shell. Příklad pokusu o Azure Cloud Shell
V prohlížeči otevřete Cloud Shell kliknutím na tlačítko Spustit Cloud Shell. https://shell.azure.comGo to https://shell.azure.com or select the Launch Cloud Shell button to open Cloud Shell in your browser. Spustit Cloud Shell v novém okněLaunch Cloud Shell in a new window
Vyberte tlačítko Cloud Shell v pravém horním panelu nabídek v Azure Portal.Select the Cloud Shell button on the top-right menu bar in the Azure portal. Tlačítko Cloud Shell na webu Azure Portal

Chcete-li spustit kód v tomto článku v Azure Cloud Shell:To run the code in this article in Azure Cloud Shell:

  1. Otevřete Cloud Shell.Open Cloud Shell.
  2. Vyberte tlačítko Kopírovat na bloku kódu ke zkopírování kódu.Select the Copy button on a code block to copy the code.
  3. Vložte kód do relace Cloud Shell stisknutím kombinace kláves CTRL+SHIFT+v v systému Windows a Linux nebo příkazem cmd+SHIFT+v v MacOS.Paste the code into the Cloud Shell session with Ctrl+Shift+V on Windows and Linux, or Cmd+Shift+V on macOS.
  4. Stiskněte klávesu ENTER pro spuštění kódu.Press Enter to run the code.

Přihlásit se k AzureSign in to Azure

Pokud používáte vyzkoušet tlačítko Spustit Cloud Shell, přihlaste se k Azure pomocí přihlašovacích údajů.If you use the Try It button to launch the Cloud Shell, sign in to Azure using your credentials.

Pokud jste spustili službě Cloud Shell ve webovém prohlížeči buď přímo, nebo na webu Azure Portal, přepněte na Bash Pokud se zobrazí Powershellu v horní části levého horního rohu službě Cloud Shell.If you launched the Cloud Shell in your Web browser either directly or in the Azure portal, switch to Bash if you see PowerShell in the top-left corner of the Cloud Shell.

Vytvoření prostředků pomocí Azure CLIUse the Azure CLI to create resources

Ve službě Cloud Shell zřiďte v příkazovém řádku Bash pomocí následujících příkazů prostředky služby Service Bus.In Cloud Shell, from the Bash prompt issue the following commands to provision Service Bus resources. Nezapomeňte všechny zástupné symboly nahradit příslušnými hodnotami: Ukázkový program v jazyce Java očekává, že název fronty, který se má BasicQueue, takže neměňte ho.Be sure to replace all placeholders with the appropriate values: The Java sample program expects the queue name to be BasicQueue, so do not change it. Můžete chtít kopírování/vkládání příkazy jeden po druhém, takže můžete nahradit hodnoty před spuštěním je.You may want to copy/paste commands one-by-one so that you can replace the values before you run them.

# Create a resource group
resourceGroupName="myResourceGroup"

az group create --name $resourceGroupName --location eastus

# Create a Service Bus messaging namespace with a unique name
namespaceName=myNameSpace$RANDOM
az servicebus namespace create --resource-group $resourceGroupName --name $namespaceName --location eastus

# Create a Service Bus queue
az servicebus queue create --resource-group $resourceGroupName --namespace-name $namespaceName --name BasicQueue

# Get the connection string for the namespace
connectionString=$(az servicebus namespace authorization-rule keys list --resource-group $resourceGroupName --namespace-name $namespaceName --name RootManageSharedAccessKey --query primaryConnectionString --output tsv)

Po dokončení všech příkazů zkopírujte vybraný připojovací řetězec a název fronty a vložte je do dočasného umístění, třeba do Poznámkového bloku.After the last command runs, copy and paste the connection string, and the queue name you selected, to a temporary location such as Notepad. Budete je potřebovat v dalším kroku.You will need it in the next step.

Odesílání a příjem zprávSend and receive messages

Když vytvoříte obor názvů a frontu a máte potřebná pověření, jste připraveni odesílat a přijímat zprávy.After you've created the namespace and queue, and you have the necessary credentials, you are ready to send and receive messages. Kód můžete zkontrolovat v této složce s ukázkami na GitHubu.You can examine the code in this GitHub sample folder.

  1. Klonování úložiště GitHub služby Service Bus v počítači pomocí následujícího příkazu:Clone the Service Bus GitHub repository on your computer by issuing the following command:

    git clone https://github.com/Azure/azure-service-bus.git
    
  2. Změňte svůj aktuální adresář na složku s ukázkou použitím lomítek jako oddělovačů cest:Change your current directory to the sample folder, using forward slashes as path separators:

    cd azure-service-bus/samples/Java/azure-servicebus/QueuesGettingStarted
    
  3. Proveďte následující příkaz, kterým vytvoříte aplikaci:Issue the following command to build the application:

    mvn clean package -DskipTests
    
  4. Chcete-li spustit program, vydejte následující příkaz po nahrazení připojovací řetězec s hodnotou, kterou jste si zkopírovali dříve:To run the program, issue the following command after replacing the connection string with the value you copied earlier:

    java -jar ./target/queuesgettingstarted-1.0.0-jar-with-dependencies.jar -c "<SERVICE BUS NAMESPACE CONNECTION STRING>" 
    
  5. Sledujte, jak se do fronty odešle 10 zpráv.Observe 10 messages being sent to the queue. Řazení zpráv, které není zaručeno, ale můžete zobrazit zprávy odesílá, pak potvrzení a přijetí spolu s daty o datové části:Ordering of messages is not guaranteed, but you can see the messages sent, then acknowledged and received, along with the payload data:

    Message sending: Id = 0
    Message sending: Id = 1
    Message sending: Id = 2
    Message sending: Id = 3
    Message sending: Id = 4
    Message sending: Id = 5
    Message sending: Id = 6
    Message sending: Id = 7
    Message sending: Id = 8
    Message sending: Id = 9
            Message acknowledged: Id = 9
            Message acknowledged: Id = 3
                                    Message received:
                                                    MessageId = 9,
                                                    SequenceNumber = 54324670505156609,
                                                    EnqueuedTimeUtc = 2019-02-25T18:15:20.972Z,
                                                    ExpiresAtUtc = 2019-02-25T18:17:20.972Z,
                                                    ContentType = "application/json",
                                                    Content: [ firstName = Nikolaus, name = Kopernikus ]
    
            Message acknowledged: Id = 2
            Message acknowledged: Id = 5
            Message acknowledged: Id = 1
            Message acknowledged: Id = 8
            Message acknowledged: Id = 7
            Message acknowledged: Id = 0
            Message acknowledged: Id = 6
            Message acknowledged: Id = 4
                                    Message received:
                                                    MessageId = 3,
                                                    SequenceNumber = 58828270132527105,
                                                    EnqueuedTimeUtc = 2019-02-25T18:15:20.972Z,
                                                    ExpiresAtUtc = 2019-02-25T18:17:20.972Z,
                                                    ContentType = "application/json",
                                                    Content: [ firstName = Steven, name = Hawking ]
    
                                    Message received:
                                                    MessageId = 2,
                                                    SequenceNumber = 9288674231451649,
                                                    EnqueuedTimeUtc = 2019-02-25T18:15:21.012Z,
                                                    ExpiresAtUtc = 2019-02-25T18:17:21.012Z,
                                                    ContentType = "application/json",
                                                    Content: [ firstName = Marie, name = Curie ]
    
                                    Message received:
                                                    MessageId = 1,
                                                    SequenceNumber = 22799473113563137,
                                                    EnqueuedTimeUtc = 2019-02-25T18:15:21.025Z,
                                                    ExpiresAtUtc = 2019-02-25T18:17:21.025Z,
                                                    ContentType = "application/json",
                                                    Content: [ firstName = Werner, name = Heisenberg ]
    
                                    Message received:
                                                    MessageId = 8,
                                                    SequenceNumber = 67835469387268097,
                                                    EnqueuedTimeUtc = 2019-02-25T18:15:21.028Z,
                                                    ExpiresAtUtc = 2019-02-25T18:17:21.028Z,
                                                    ContentType = "application/json",
                                                    Content: [ firstName = Johannes, name = Kepler ]
    
                                    Message received:
                                                    MessageId = 7,
                                                    SequenceNumber = 4785074604081153,
                                                    EnqueuedTimeUtc = 2019-02-25T18:15:21.020Z,
                                                    ExpiresAtUtc = 2019-02-25T18:17:21.020Z,
                                                    ContentType = "application/json",
                                                    Content: [ firstName = Galileo, name = Galilei ]
    
                                    Message received:
                                                    MessageId = 5,
                                                    SequenceNumber = 13792273858822145,
                                                    EnqueuedTimeUtc = 2019-02-25T18:15:21.027Z,
                                                    ExpiresAtUtc = 2019-02-25T18:17:21.027Z,
                                                    ContentType = "application/json",
                                                    Content: [ firstName = Niels, name = Bohr ]
    
                                    Message received:
                                                    MessageId = 0,
                                                    SequenceNumber = 18295873486192641,
                                                    EnqueuedTimeUtc = 2019-02-25T18:15:21.021Z,
                                                    ExpiresAtUtc = 2019-02-25T18:17:21.021Z,
                                                    ContentType = "application/json",
                                                    Content: [ firstName = Albert, name = Einstein ]
    
                                    Message received:
                                                    MessageId = 6,
                                                    SequenceNumber = 281474976710657,
                                                    EnqueuedTimeUtc = 2019-02-25T18:15:21.019Z,
                                                    ExpiresAtUtc = 2019-02-25T18:17:21.019Z,
                                                    ContentType = "application/json",
                                                    Content: [ firstName = Michael, name = Faraday ]
    
                                    Message received:
                                                    MessageId = 4,
                                                    SequenceNumber = 63331869759897601,
                                                    EnqueuedTimeUtc = 2019-02-25T18:15:20.964Z,
                                                    ExpiresAtUtc = 2019-02-25T18:17:20.964Z,
                                                    ContentType = "application/json",
                                                    Content: [ firstName = Isaac, name = Newton ]
    

Vyčištění prostředkůClean up resources

Ve službě Azure Cloud Shell spuštěním následujícího příkazu odeberte skupinu prostředků, obor názvů a všechny související prostředky:In the Azure Cloud Shell, run the following command to remove the resource group, namespace, and all related resources:

az group delete --resource-group myResourceGroup

Vysvětlení vzorového kóduUnderstand the sample code

Tato část obsahuje další podrobnosti o klíčových částech vzorového kódu.This section contains more details about key sections of the sample code. Kód si můžete prohlédnout zde na úložišti GitHub.You can browse the code, located in the GitHub repository here.

Získání připojovacího řetězceGet connection string

Metoda akce přečte hodnotu připojovacího řetězce z argumentů do programu.The runApp method reads the connection string value from the arguments to the program.

public static void main(String[] args) {

    System.exit(runApp(args, (connectionString) -> {
        QueuesGettingStarted app = new QueuesGettingStarted();
        try {
            app.run(connectionString);
            return 0;
        } catch (Exception e) {
            System.out.printf("%s", e.toString());
            return 1;
        }
    }));
}

    static final String SB_SAMPLES_CONNECTIONSTRING = "SB_SAMPLES_CONNECTIONSTRING";

    public static int runApp(String[] args, Function<String, Integer> run) {
        try {

            String connectionString = null;

            // parse connection string from command line
            Options options = new Options();
            options.addOption(new Option("c", true, "Connection string"));
            CommandLineParser clp = new DefaultParser();
            CommandLine cl = clp.parse(options, args);
            if (cl.getOptionValue("c") != null) {
                connectionString = cl.getOptionValue("c");
            }

            // get overrides from the environment
            String env = System.getenv(SB_SAMPLES_CONNECTIONSTRING);
            if (env != null) {
                connectionString = env;
            }

            if (connectionString == null) {
                HelpFormatter formatter = new HelpFormatter();
                formatter.printHelp("run jar with", "", options, "", true);
                return 2;
            }
            return run.apply(connectionString);
        } catch (Exception e) {
            System.out.printf("%s", e.toString());
            return 3;
        }
    }

Vytvoření klientů fronty k odesílání a přijímání zprávCreate queue clients to send and receive

Abyste mohli odesílat a přijímat zprávy, metoda run() vytvoří instance klienta fronty, které se skládají z připojovacího řetězce a názvu fronty.To send and receive messages, the run() method creates queue client instances, which are constructed from the connection string and the queue name. Tento kód vytvoří dva klienty fronty – jednoho pro odesílání a jednoho pro přijímání zpráv:This code creates two queue clients, one each for sending and receiving:

public void run(String connectionString) throws Exception {

    // Create a QueueClient instance for receiving using the connection string builder
    // We set the receive mode to "PeekLock", meaning the message is delivered
    // under a lock and must be acknowledged ("completed") to be removed from the queue
    QueueClient receiveClient = new QueueClient(new ConnectionStringBuilder(connectionString, "BasicQueue"), ReceiveMode.PEEKLOCK);
    // We are using single thread executor as we are only processing one message at a time
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    this.registerReceiver(receiveClient, executorService);

    // Create a QueueClient instance for sending and then asynchronously send messages.
    // Close the sender once the send operation is complete.
    QueueClient sendClient = new QueueClient(new ConnectionStringBuilder(connectionString, "BasicQueue"), ReceiveMode.PEEKLOCK);
    this.sendMessagesAsync(sendClient).thenRunAsync(() -> sendClient.closeAsync());

    // wait for ENTER or 10 seconds elapsing
    waitForEnter(10);

    // shut down receiver to close the receive loop
    receiveClient.close();
    executorService.shutdown();
}

Vytvoření a odeslání zprávConstruct and send messages

Metoda sendMessagesAsync() vytvoří sadu deseti zpráv a pomocí klienta fronty je asynchronně odešle:The sendMessagesAsync() method creates a set of 10 messages and asynchronously sends them using the queue client:

CompletableFuture<Void> sendMessagesAsync(QueueClient sendClient) {
    List<HashMap<String, String>> data =
            GSON.fromJson(
                    "[" +
                            "{'name' = 'Einstein', 'firstName' = 'Albert'}," +
                            "{'name' = 'Heisenberg', 'firstName' = 'Werner'}," +
                            "{'name' = 'Curie', 'firstName' = 'Marie'}," +
                            "{'name' = 'Hawking', 'firstName' = 'Steven'}," +
                            "{'name' = 'Newton', 'firstName' = 'Isaac'}," +
                            "{'name' = 'Bohr', 'firstName' = 'Niels'}," +
                            "{'name' = 'Faraday', 'firstName' = 'Michael'}," +
                            "{'name' = 'Galilei', 'firstName' = 'Galileo'}," +
                            "{'name' = 'Kepler', 'firstName' = 'Johannes'}," +
                            "{'name' = 'Kopernikus', 'firstName' = 'Nikolaus'}" +
                            "]",
                    new TypeToken<List<HashMap<String, String>>>() {}.getType());

    List<CompletableFuture> tasks = new ArrayList<>();
    for (int i = 0; i < data.size(); i++) {
        final String messageId = Integer.toString(i);
        Message message = new Message(GSON.toJson(data.get(i), Map.class).getBytes(UTF_8));
        message.setContentType("application/json");
        message.setLabel("Scientist");
        message.setMessageId(messageId);
        message.setTimeToLive(Duration.ofMinutes(2));
        System.out.printf("\nMessage sending: Id = %s", message.getMessageId());
        tasks.add(
                sendClient.sendAsync(message).thenRunAsync(() -> {
                    System.out.printf("\n\tMessage acknowledged: Id = %s", message.getMessageId());
                }));
    }
    return CompletableFuture.allOf(tasks.toArray(new CompletableFuture<?>[tasks.size()]));
}

Příjem zprávReceive messages

Metoda registerReceiver() zaregistruje zpětné volání RegisterMessageHandler a zároveň nastaví některé možnosti popisovače zpráv:The registerReceiver() method registers the RegisterMessageHandler callback and also sets some message handler options:

void registerReceiver(QueueClient queueClient, ExecutorService executorService) throws Exception {

    
    // register the RegisterMessageHandler callback with executor service
    queueClient.registerMessageHandler(new IMessageHandler() {
                                            // callback invoked when the message handler loop has obtained a message
                                            public CompletableFuture<Void> onMessageAsync(IMessage message) {
                                                // receives message is passed to callback
                                                if (message.getLabel() != null &&
                                                        message.getContentType() != null &&
                                                        message.getLabel().contentEquals("Scientist") &&
                                                        message.getContentType().contentEquals("application/json")) {

                                                    byte[] body = message.getBody();
                                                    Map scientist = GSON.fromJson(new String(body, UTF_8), Map.class);

                                                    System.out.printf(
                                                            "\n\t\t\t\tMessage received: \n\t\t\t\t\t\tMessageId = %s, \n\t\t\t\t\t\tSequenceNumber = %s, \n\t\t\t\t\t\tEnqueuedTimeUtc = %s," +
                                                                    "\n\t\t\t\t\t\tExpiresAtUtc = %s, \n\t\t\t\t\t\tContentType = \"%s\",  \n\t\t\t\t\t\tContent: [ firstName = %s, name = %s ]\n",
                                                            message.getMessageId(),
                                                            message.getSequenceNumber(),
                                                            message.getEnqueuedTimeUtc(),
                                                            message.getExpiresAtUtc(),
                                                            message.getContentType(),
                                                            scientist != null ? scientist.get("firstName") : "",
                                                            scientist != null ? scientist.get("name") : "");
                                                }
                                                return CompletableFuture.completedFuture(null);
                                            }

                                            // callback invoked when the message handler has an exception to report
                                            public void notifyException(Throwable throwable, ExceptionPhase exceptionPhase) {
                                                System.out.printf(exceptionPhase + "-" + throwable.getMessage());
                                            }
                                        },
            // 1 concurrent call, messages are auto-completed, auto-renew duration
            new MessageHandlerOptions(1, true, Duration.ofMinutes(1)),
            executorService);

}

Poznámka

Můžete spravovat prostředky služby Service Bus s Service Bus Exploreru.You can manage Service Bus resources with Service Bus Explorer. Service Bus Exploreru umožňuje uživatelům připojit k oboru názvů služby Service Bus a správě entit pro zasílání zpráv snadno způsobem.The Service Bus Explorer allows users to connect to a Service Bus namespace and administer messaging entities in an easy manner. Tento nástroj nabízí pokročilé funkce, například funkce importu/exportu nebo možnost otestovat tématu, fronty, předplatná, služby pro přenos přes, notification hubs a centra událostí.The tool provides advanced features like import/export functionality or the ability to test topic, queues, subscriptions, relay services, notification hubs and events hubs.

Další postupNext steps

V tomto článku jste vytvořil obor názvů služby Service Bus a další prostředky potřebné k odesílání a přijímání zpráv z fronty.In this article, you created a Service Bus namespace and other resources required to send and receive messages from a queue. Další informace o psaní kódu pro odesílání a příjem zpráv, pokračovat v kurzech odesílání a příjem zpráv oddílu.To learn more about writing code to send and receive messages, continue to the tutorials in the Send and receive messages section.